Example #1
0
    async def test_compute_rollover_weekly_attime(self):
        current_time = int(time.time())
        today = current_time - current_time % 86400

        at_time = datetime.time(12, 0, 0)

        week_day = time.gmtime(today).tm_wday
        for day, interval in enumerate(RolloverInterval.WEEK_DAYS):
            handler = AsyncTimedRotatingFileHandler(
                filename=self.temp_file.name,
                when=interval,
                interval=1,
                backup_count=0,
                utc=True,
                at_time=at_time,
            )
            try:
                if week_day > day:
                    # The rollover day has already passed this week, so we
                    # go over into next week
                    expected = 7 - week_day + day
                else:
                    expected = day - week_day
                # At this point expected is in days from now, convert to seconds
                expected *= ONE_DAY_IN_SECONDS
                # Add in the rollover time
                expected += 12 * 60 * 60
                # Add in adjustment for today
                expected += today
                actual = handler.compute_rollover(today)
                self.assertEqual(actual,
                                 expected,
                                 msg=f"failed in timezone: {time.timezone}")

                if day == week_day:
                    # goes into following week
                    expected += ONE_WEEK_IN_SECONDS

                actual = handler.compute_rollover(today + 13 * 60 * 60)
                self.assertEqual(actual,
                                 expected,
                                 msg=f"failed in timezone: {time.timezone}")
            finally:
                await handler.close()
Example #2
0
    async def test_compute_rollover_daily_attime(self):
        current_time = 0
        at_time = datetime.time(12, 0, 0)
        handler = AsyncTimedRotatingFileHandler(
            self.temp_file.name,
            when=RolloverInterval.MIDNIGHT,
            interval=1,
            backup_count=0,
            utc=True,
            at_time=at_time,
        )
        try:
            actual = handler.compute_rollover(current_time)
            self.assertEqual(actual, current_time + 12 * 60 * 60)

            actual = handler.compute_rollover(current_time + 13 * 60 * 60)
            self.assertEqual(actual, current_time + 36 * 60 * 60)
        finally:
            await handler.close()
Example #3
0
 async def test_compute_rollover_daily(self):
     current_time = 0
     handler = AsyncTimedRotatingFileHandler(
         self.temp_file.name,
         when=RolloverInterval.MIDNIGHT,
         interval=1,
         backup_count=0,
         utc=True,
     )
     try:
         actual = handler.compute_rollover(current_time)
         self.assertEqual(actual, current_time + ONE_DAY_IN_SECONDS)
     finally:
         await handler.close()