Esempio n. 1
0
 def test_warn_log_trace(self):
     log = Diary(self.WARNINGS_LOG_PATH, async=False)
     log.warn(self.INFO, log_trace=True)
     log.close()
     with open(log.log_file.name) as f:
         self.assertTrue(
             "logged(event, *args, **kwargs)" in f.read())
Esempio n. 2
0
 def test_init_does_not_exist(self):
     log = Diary(self.NO_EXIST_PATH, async=False)
     log.info(self.INFO)
     log.close()
     with open(self.NO_EXIST_PATH) as f:
         line = f.readline()
         self.assertTrue(self.INFO in line)
Esempio n. 3
0
 def test_init_file(self):
     log = Diary(self.TXT_PATH, async=False)
     log.info(self.INFO)
     log.close()
     with open(self.TXT_PATH) as f:
         line = f.readline()
         self.assertTrue(self.INFO in line)
Esempio n. 4
0
    def test_log_event_instance(self):
        mock_level = "CRITICAL"
        log = Diary(self.INIT_DIR, db_name="events.db", async=False)
        e = Event(self.INFO, level=mock_level)
        log.log(e)
        self.assertEquals(e.level, mock_level)

        log.close()
        with DiaryDB(log.db_file.name) as db:
            db.assert_event_logged(self.INFO, level=mock_level)
Esempio n. 5
0
    def test_custom_format_init(self):
        logger = Diary(self.API_DIR, log_format=emergency_format,
                       file_name="EmergencyLogs2.log", db_name="EmergencyDB2.db")

        logger.log(self.INFO)
        logger.close()
        with open(logger.log_file.name) as f:
            self.assertEquals(f.readline(), emergency_format(logger.last_logged_event) + '\n')

        with DiaryDB(logger.db_file.name) as db:
            db.assert_event_logged(self.INFO)
Esempio n. 6
0
    def test_queue_join(self):
        trials = 10
        log = Diary(self.INIT_DIR, async=True, db_name="QUEUE_TEST.db")
        for i in range(trials):
            log.log(i)

        log.close()
        self.assertFalse(log.thread.is_alive())
        with DiaryDB(log.db_file.name) as db:
            entries = db.cursor.execute("SELECT * FROM logs")
            self.assertEquals(len(entries.fetchall()), trials)
Esempio n. 7
0
    def test_log_event_formatted(self):
        log = Diary(self.INIT_DIR, file_name="formatted.log", async=False)
        e = Event(self.INFO, "LEVEL")
        e.set_formatter("{info}|{level}")
        log.log(e)
        log.close()

        with open(log.log_file.name) as f:
            self.assertEquals("{info}|{level}\n".format(info=self.INFO, level="LEVEL"), f.readline())

        e.set_formatter(None) # Set Event formatter back to None to not upset other tests
Esempio n. 8
0
    def test_diary_print(self):
        log = Diary(self.INIT_DIR, file_name="printing.log", also_print=True)

        info_to_log = "hello there world!!!"

        log.info(info_to_log)

        log.close()

        # Nothing bad happened and stdout is hard to capture reliably
        with open(log.log_file.name) as f:
            self.assertTrue(info_to_log in f.readline())
Esempio n. 9
0
    def test_log_event_in_init(self):
        class PrettyEvent(Event):
            formatter = "{info}|{level_str}"

        log = Diary(self.INIT_DIR, file_name="pretty.log", db_name="prettyevents.db", async=False, event=PrettyEvent)
        log.log(self.INFO)
        log.close()

        with DiaryDB(log.db_file.name) as db:
            db.assert_event_logged(self.INFO)

        with open(log.log_file.name) as f:
            self.assertEquals("{info}|{level}\n".format(info=self.INFO, level="INFO"), f.readline())
Esempio n. 10
0
    def test_custom_format_event(self):
        class FormattedEvent(Event):
            formatter = "|{dt}|{info}|{level_str}|"

        logger = Diary(self.API_DIR, file_name="formatted.txt", db_name="formattedDB.db", event=FormattedEvent, async=False)
        logger.log(self.INFO)
        logger.close()

        with open(logger.log_file.name) as f:
            self.assertEquals(f.readline(), logger.last_logged_event.formatted() + '\n')

        with DiaryDB(logger.db_file.name) as db:
            db.assert_event_logged(self.INFO, "INFO")
Esempio n. 11
0
    def test_custom_event(self):
        logger = Diary(self.API_DIR, file_name="UserEvents.txt", event=UserEvent)
        logger.log("Start logging")
        logger.info(UserEvent(self.INFO, user_name="admin"))  # Directly log events
        logger.close()

        with open(logger.log_file.name) as f:
            contents = f.read()
            self.assertTrue("Start logging" in contents)
            self.assertTrue(logger.last_logged_event.formatted() in contents)

        with DiaryDB(logger.db_file.name) as db:
            db.assert_event_logged(self.INFO, "INFO")
Esempio n. 12
0
    def test_unicode_PY2(self):
        if not _PY2:
            return

        unicode_str = u"\u3002"
        log = Diary(os.path.join(self.INIT_DIR, "unicode_test.log"), async=False, encoding="utf-8")

        log.log(unicode_str)

        log.close()

        with codecs.open(log.log_file.name, encoding=log.encoding) as f:
            line = f.readline()
            self.assertTrue(unicode_str in line)
Esempio n. 13
0
    def test_unicode_PY3(self):
        if _PY2:
            return

        unicode_str = u"\u3002"
        log = Diary(self.INIT_DIR, file_name="unicode_test.log", async=False)

        log.log(unicode_str)

        log.close()

        with codecs.open(log.log_file.name, encoding=log.encoding) as f:
            line = f.readline()
            self.assertTrue(unicode_str in line)
Esempio n. 14
0
    def test_unicode_event_formatted(self):
        class PrettyEvent(Event):
            formatter = "{info}|{level_str}"

        unicode_str = u"\u3002"
        log = Diary(os.path.join(self.INIT_DIR, "unicode_test.log"), async=False, encoding="utf-8", event=PrettyEvent)

        log.log(unicode_str)

        log.close()

        with codecs.open(log.log_file.name, encoding=log.encoding) as f:
            line = f.readline()
            self.assertTrue(unicode_str in line)
Esempio n. 15
0
    def test_log(self):
        FILE_NAME = "test_log.txt"
        log = Diary(self.INIT_DIR, async=False, file_name=FILE_NAME)
        self.assertTrue(exists_with_ext(os.path.join(
            self.INIT_DIR,
            FILE_NAME
            ), '.txt')
        )

        log.log(self.INFO)
        log.logdb.assert_event_logged(self.INFO, level="INFO", limit=1)
        log.close()

        self.assertEquals(os.path.split(log.log_file.name)[-1], FILE_NAME)

        with open(os.path.join(self.INIT_DIR, FILE_NAME)) as f:
            self.assertTrue(self.INFO in f.readline())
Esempio n. 16
0
    def test_levels_setting_levels(self):
        log = Diary(self.INIT_DIR, db_name="levels.db", async=False)
        e = Event(self.INFO, level="")
        log.info(e)
        self.assertIs(e.level, levels.info)
        log.warn(e)
        self.assertIs(e.level, levels.warn)
        log.error(e)
        self.assertIs(e.level, levels.error)
        log.debug(e)
        self.assertIs(e.level, levels.debug)

        log.close()

        with DiaryDB(log.db_file.name) as db:
            db.assert_event_logged(self.INFO, level="INFO", limit=4)
            db.assert_event_logged(self.INFO, level="WARN", limit=4)
            db.assert_event_logged(self.INFO, level="ERROR", limit=4)
            db.assert_event_logged(self.INFO, level="DEBUG", limit=4)
Esempio n. 17
0
    def test_custom_everything(self):
        logger = Diary(self.API_DIR, file_name="withlevel.txt", db_name="level_user_events.db",
                       db=UserActivityDB, event=UserEvent)
        event_to_log = UserEvent(self.INFO, user_name="super")
        logger.log(event_to_log, level=critical)
        logger.close()
        with open(logger.log_file.name) as f:
            self.assertTrue(event_to_log.formatted() + '\n', f.readline())

        with UserActivityDB(logger.db_file.name) as db:
            entries = db.cursor.execute("""SELECT * FROM user_activity WHERE
                                        log=(?) AND level LIKE (?) AND user=(?)""",
                              (event_to_log.info, event_to_log.level_str, event_to_log.user_name))
            entry = entries.fetchone()

            self.assertEquals(entry[0], event_to_log.dt)
            self.assertEquals(entry[1], event_to_log.level_str)
            self.assertEquals(entry[2], event_to_log.info)
            self.assertEquals(entry[3], event_to_log.user_name)
Esempio n. 18
0
    def test_write(self):
        FILE_NAME = "test_write.txt"
        log = Diary(self.INIT_DIR, async=False, file_name=FILE_NAME)
        simple_event = Event(self.INFO, "LEVEL")

        self.assertTrue(exists_with_ext(os.path.join(
            self.INIT_DIR,
            FILE_NAME
            ), '.txt')
        )

        log._write(simple_event)
        log.logdb.assert_event_logged(self.INFO, level="LEVEL")
        log.close()

        self.assertEquals(os.path.split(log.log_file.name)[-1], FILE_NAME)
        self.assertIs(log.last_logged_event, simple_event)

        with open(os.path.join(self.INIT_DIR, FILE_NAME)) as f:
            self.assertTrue(self.INFO in f.readline())
Esempio n. 19
0
    def test_custom_db_formatted_event(self):
        logger = Diary(self.API_DIR, file_name="withdb.txt", db_name="user_events.db",
                       db=UserActivityDB, event=UserEvent)

        logger.log("Starting app")
        event_to_log = UserEvent("Super user logged in", user_name="super")
        logger.debug(event_to_log)
        logger.close()
        with open(logger.log_file.name) as f:
            contents = f.read()
            self.assertTrue("Starting app" in contents)
            self.assertTrue(logger.last_logged_event.formatted() in contents)

        with UserActivityDB(logger.db_file.name) as db:
            entries = db.cursor.execute("""SELECT * FROM user_activity WHERE
                                        log=(?) AND level LIKE (?) AND user=(?)""",
                              (event_to_log.info, event_to_log.level_str, event_to_log.user_name))
            entry = entries.fetchone()

            self.assertEquals(entry[0], event_to_log.dt)
            self.assertEquals(entry[1], event_to_log.level_str)
            self.assertEquals(entry[2], event_to_log.info)
            self.assertEquals(entry[3], event_to_log.user_name)
Esempio n. 20
0
 def test_warn(self):
     DB_NAME = 'levels.db'
     log = Diary(os.path.join(self.INIT_DIR), async=False, db_name=DB_NAME)
     log.warn(self.INFO)
     log.logdb.assert_event_logged(self.INFO, "WARN", 1)
     log.close()
Esempio n. 21
0
class TestDiaryThread(unittest.TestCase):
    TEST_DIR_PATH = os.path.join(os.path.dirname(__file__),
                                 'testing_dir')
    INFO = "event was logged"
    TEMP_DB = os.path.join(TEST_DIR_PATH, "db_test.db")
    TEMP_FILE = os.path.join(TEST_DIR_PATH, "thread_test.txt")
    TRIALS = 3
    count = 0

    def setUp(self):
        self.log = Diary(self.TEST_DIR_PATH, file_name=self.TEMP_FILE,
                         db_name=self.TEMP_DB, async=True)

    def tearDown(self):
        self.log.close()
        os.remove(self.TEMP_FILE)

    @classmethod
    def tearDownClass(cls):
        os.remove(cls.TEMP_DB)

    def test_constructor(self):
        self.assertIsNotNone(self.log.thread)
        self.assertTrue(self.log.thread.isDaemon())
        self.assertTrue(self.log.thread.sets_db)
        self.assertIs(self.log.thread.diary, self.log)

    def test_join(self):
        returned = self.log.thread.join()
        self.assertIsNone(returned)

    def test_logs(self):
        self.log.log(self.INFO)
        self.log.close()

        with open(self.log.log_file.name) as f:
            self.assertTrue(self.INFO in f.readline())

        with DiaryDB(self.log.db_file.name) as db:
            db.assert_event_logged(self.INFO)

    def test_timer_no_async(self):
        log = Diary(self.TEST_DIR_PATH, async=False)
        with self.assertRaises(RuntimeError,
            msg="In order to set a timer async must be enabled"):
            log.set_timer(100, lambda: None)

    def test_timer(self):
        def log_counter():
            self.count += 1
            self.log.log(self.INFO + str(self.count))

        self.log.set_timer(1, log_counter)

        time.sleep(self.TRIALS + .1)

        self.log.close()

        with DiaryDB(self.log.db_file.name) as db:
            db.assert_event_logged(self.INFO + str(self.count))

        with open(self.log.log_file.name) as f:
            for i in range(1, self.TRIALS + 1):
                self.assertTrue(self.INFO + str(i) in f.readline())

    def test_timer_with_args(self):
        def log_arg(arg):
            self.log.log(arg)

        self.log.set_timer(1, log_arg, self.INFO)

        time.sleep(self.TRIALS + .1)

        self.log.close()

        with DiaryDB(self.log.db_file.name) as db:
            entries = db.cursor.execute(
                '''SELECT * FROM logs WHERE log=(?)
                AND level LIKE (?) ORDER BY
                inputDT ASC LIMIT (?)''',
                (self.INFO, '%', self.TRIALS))

            for i in range(self.TRIALS):
                self.assertTrue(entries.fetchone())

        with open(self.log.log_file.name) as f:
            self.assertTrue(self.INFO in f.readline())

    def test_timer_with_kwargs(self):
        repeats = 10

        def log_kwarg(s, repeats=2):
            self.log.log(s * repeats)

        self.log.set_timer(1, log_kwarg, self.INFO, repeats=repeats)

        time.sleep(self.TRIALS + .1)

        self.log.close()

        with DiaryDB(self.log.db_file.name) as db:
            entries = db.cursor.execute(
                '''SELECT * FROM logs WHERE log=(?)
                AND level LIKE (?) ORDER BY
                inputDT ASC LIMIT (?)''',
                (self.INFO * repeats, '%', self.TRIALS))

            for i in range(self.TRIALS):
                self.assertTrue(entries.fetchone())

        with open(self.log.log_file.name) as f:
            self.assertTrue(self.INFO * repeats in f.readline())

    def test_timer_all_args(self):
        params = (self.INFO, "abc", "def", "123")

        def log_joined(*args):
            self.log.log(' '.join(args))

        self.log.set_timer(1, log_joined, *params)

        time.sleep(self.TRIALS + .1)

        self.log.close()

        with DiaryDB(self.log.db_file.name) as db:
            entries = db.cursor.execute(
                '''SELECT * FROM logs WHERE log=(?)
                AND level LIKE (?) ORDER BY
                inputDT ASC LIMIT (?)''',
                (' '.join(params), '%', self.TRIALS))

            for i in range(self.TRIALS):
                self.assertTrue(entries.fetchone())

        with open(self.log.log_file.name) as f:
            self.assertTrue(' '.join(params) in f.readline())
Esempio n. 22
0
 def test_error_log_trace(self):
     log = Diary(self.ERRORS_LOG_PATH, async=False )
     log.error("ERROR", log_trace=True)
     log.close()
     with open(log.log_file.name) as f:
         self.assertTrue('log.error("ERROR", log_trace=True)' in f.read())
Esempio n. 23
0
 def test_error(self):
     DB_NAME = 'levels.db'
     log = Diary(os.path.join(self.INIT_DIR), async=False, db_name=DB_NAME)
     log.error(self.INFO, log_trace=False)
     log.logdb.assert_event_logged(self.INFO, "ERROR", 1)
     log.close()
Esempio n. 24
0
 def test_custom_level(self):
     logger = Diary(os.path.join(self.API_DIR))
     logger.log("URGENT ATTENTION NEEDED", level=critical)
     logger.close()
     with open(logger.log_file.name) as f:
         self.assertEquals(f.readline(), formats.standard(logger.last_logged_event) + '\n')
Esempio n. 25
0
 def test_debug(self):
     DB_NAME = 'levels.db'
     log = Diary(self.INIT_DIR, async=False, db_name=DB_NAME)
     log.debug(self.INFO)
     log.logdb.assert_event_logged(self.INFO, "DEBUG", 1)
     log.close()
Esempio n. 26
0
target_dir = "data"
# files_to_process = os.listdir(target_dir)
files_to_process = range(10) # We will pretend the numbers up to 10 are files


for f in files_to_process:
    if process_file(f) == 1:
        e = FileProcessEvent("Success!", 1, f)
        logger.info(e)
    elif process_file(f) == 2:
        e = FileProcessEvent("The goal was not achieved", 2, f)
        logger.warn(e)
    elif process_file(f) == 3:
        e = FileProcessEvent("An error occurred", 3, f)
        logger.error(e)
    else:
        e = FileProcessEvent("Could not process file", -1, f)
        logger.debug(e)

logger.close()

with DiaryDB(logger.db_file.name) as db:

    entries = db.cursor.execute('''
                SELECT * FROM files
                ''')
    for row in entries:
        print(row)

Esempio n. 27
0
 def test_init_no_ext(self):
     log = Diary(self.NO_EXT_PATH, async=False)
     log.info(self.INFO)
     log.close()
     with open(self.NO_EXT_PATH) as f:
         self.assertTrue(self.INFO in f.readline())
Esempio n. 28
0
 def test_init_new_db(self):
     log = Diary(self.NEW_DB_PATH, async=False)
     log.info(self.INFO)
     log.close()
     with DiaryDB(self.NEW_DB_PATH) as db:
         db.assert_event_logged(self.INFO, level="INFO", limit=1)