Example #1
0
    def test_process_statistics_info_add_process_without_end_time(self):

        start_time = datetime.datetime.utcnow()
        #end_time = start_time + datetime.timedelta(seconds=60)
        psi = process_statistics.ProcessStatisticsInfo(
            p_username=USERNAME,
            p_reference_time=start_time,
            p_min_activity_duration=MIN_ACTIVITY_DURATION,
            p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        self.assertEqual(psi.active_processes, 0)

        pi = process_info.ProcessInfo(p_hostname=HOSTNAME,
                                      p_username=USERNAME,
                                      p_processhandler=None,
                                      p_processname=PROCESS_NAME,
                                      p_pid=PID,
                                      p_start_time=start_time,
                                      p_end_time=None)

        psi.add_process_start(p_process_info=pi, p_start_time=pi.start_time)

        self.assertEqual(psi.active_processes, 1)

        psi.add_process_end(p_process_info=pi, p_end_time=pi.end_time)

        self.assertEqual(psi.active_processes, 0)
Example #2
0
    def test_constructor_statistics_info(self):
        reference_time = datetime.datetime.utcnow()
        psi = process_statistics.ProcessStatisticsInfo(
            p_username=USERNAME,
            p_reference_time=reference_time,
            p_min_activity_duration=MIN_ACTIVITY_DURATION,
            p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        self.assertEqual(psi.username, USERNAME)
        self.assertEqual(psi.reference_time, reference_time)
        self.assertEqual(psi.min_activity_duration, MIN_ACTIVITY_DURATION)
        self.assertEqual(psi.max_lookback_in_days, MAX_LOOKBACK_IN_DAYS)

        self.assertEqual(psi.active_processes, 0)

        self.assertIsNone(psi.last_inactivity_start_time)
        self.assertIsNone(psi.current_activity)
        self.assertIsNone(psi.previous_activity)

        self.assertEqual(psi.accumulated_break_time, 0)

        self.assertIsNotNone(psi.day_statistics)
        self.assertEqual(len(psi.day_statistics), MAX_LOOKBACK_IN_DAYS + 1)
        self.assertIsInstance(psi.day_statistics[0],
                              process_statistics.DayStatistics)

        self.assertIsNotNone(psi.currently_active_host_processes)
        self.assertEqual(len(psi.currently_active_host_processes), 0)
Example #3
0
    def test_process_statistics_info_str(self):

        start_time = datetime.datetime.utcnow()
        psi = process_statistics.ProcessStatisticsInfo(
            p_username=USERNAME,
            p_reference_time=start_time,
            p_min_activity_duration=MIN_ACTIVITY_DURATION,
            p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        self.assertIsNotNone(str(psi))
Example #4
0
    def test_max_session_duration_with_downtime(self):

        dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence(
            self._logger)
        a_rule_handler = self.create_dummy_rule_handler(
            p_persistence=dummy_persistence, p_create_complex_handlers=False)

        reference_time = datetime.datetime.utcnow()
        rule_set = TestRuleHandler.create_dummy_ruleset_config()

        activity_start = reference_time + datetime.timedelta(seconds=-1200)

        stat_info = process_statistics.ProcessStatisticsInfo(
            p_username=USERNAME,
            p_reference_time=reference_time,
            p_min_activity_duration=MIN_ACTIVITY_DURATION,
            p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        a_process_info = process_info.ProcessInfo(p_hostname=HOSTNAME,
                                                  p_username=USERNAME,
                                                  p_pid=PID,
                                                  p_start_time=activity_start,
                                                  p_downtime=300)
        stat_info.add_process_start(p_process_info=a_process_info,
                                    p_start_time=activity_start)

        # Check that playing is allowed up to the maximum session time
        rule_set.max_activity_duration = 899
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_activity_duration(
            p_rule_set=rule_set,
            p_stat_info=stat_info,
            p_rule_result_info=rule_result_info)

        self.assertEqual(
            rule_result_info.applying_rules
            & rule_handler.RULE_ACTIVITY_DURATION,
            rule_handler.RULE_ACTIVITY_DURATION)

        rule_set.max_activity_duration = 901

        # Check that playing is allowed after the maximum session time
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_activity_duration(
            p_rule_set=rule_set,
            p_stat_info=stat_info,
            p_rule_result_info=rule_result_info)

        self.assertEqual(
            rule_result_info.applying_rules
            & rule_handler.RULE_ACTIVITY_DURATION, 0)
    def test_max_time_per_day_with_downtime_and_previous_activity(self):

        dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence(self._logger)
        a_rule_handler = self.create_dummy_rule_handler(p_persistence=dummy_persistence,
                                                        p_create_complex_handlers=False)

        reference_time = datetime.datetime.utcnow()
        rule_set = TestRuleHandler.create_dummy_ruleset_config()

        activity_start = reference_time + datetime.timedelta(seconds=-2000)
        activity_end = reference_time + datetime.timedelta(seconds=-1700)

        stat_info = process_statistics.ProcessStatisticsInfo(p_username=USERNAME, p_reference_time=reference_time,
                                                             p_min_activity_duration=MIN_ACTIVITY_DURATION,
                                                             p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        a_process_info = process_info.ProcessInfo(p_hostname=HOSTNAME, p_username=USERNAME, p_pid=PID,
                                                  p_start_time=activity_start,
                                                  p_downtime=50)
        stat_info.add_process_start(p_process_info=a_process_info, p_start_time=activity_start)

        a_process_info.end_time = activity_end

        stat_info.add_process_end(p_process_info=a_process_info, p_end_time=activity_end)

        activity_start = reference_time + datetime.timedelta(seconds=-500)

        a_process_info = process_info.ProcessInfo(p_hostname=HOSTNAME, p_username=USERNAME, p_pid=PID,
                                                  p_start_time=activity_start,
                                                  p_downtime=100)
        stat_info.add_process_start(p_process_info=a_process_info, p_start_time=activity_start)

        # Check that playing is allowed up to the maximum session time
        rule_set.max_time_per_day = 649
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_time_per_day(p_rule_set=rule_set, p_stat_info=stat_info,
                                          p_rule_result_info=rule_result_info)

        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_TIME_PER_DAY,
                         rule_handler.RULE_TIME_PER_DAY)  # TODO: test error on CircleCI

        rule_set.max_time_per_day = 651

        # Check that playing is allowed after the maximum session time
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_time_per_day(p_rule_set=rule_set, p_stat_info=stat_info,
                                          p_rule_result_info=rule_result_info)

        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_TIME_PER_DAY, 0)
Example #6
0
    def test_max_time_per_day(self):

        dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence(
            self._logger)
        a_rule_handler = self.create_dummy_rule_handler(
            p_persistence=dummy_persistence, p_create_complex_handlers=False)

        reference_time = datetime.datetime.utcnow()
        rule_set = TestRuleHandler.create_dummy_ruleset_config()

        activity_start = reference_time + datetime.timedelta(seconds=-1200)

        activity = process_statistics.Activity(p_start_time=activity_start)

        stat_info = process_statistics.ProcessStatisticsInfo(
            p_username=USERNAME,
            p_reference_time=reference_time,
            p_min_activity_duration=MIN_ACTIVITY_DURATION,
            p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        stat_info.current_activity = activity

        # Check that playing is allowed up to the maximum session time
        rule_set.max_time_per_day = 1199
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_time_per_day(p_rule_set=rule_set,
                                          p_stat_info=stat_info,
                                          p_rule_result_info=rule_result_info)

        self.assertEqual(
            rule_result_info.applying_rules & rule_handler.RULE_TIME_PER_DAY,
            rule_handler.RULE_TIME_PER_DAY)

        rule_set.max_time_per_day = 1201

        # Check that playing is allowed after the maximum session time
        rule_result_info = rule_handler.RuleResultInfo()

        a_rule_handler.check_time_per_day(p_rule_set=rule_set,
                                          p_stat_info=stat_info,
                                          p_rule_result_info=rule_result_info)

        self.assertEqual(
            rule_result_info.applying_rules & rule_handler.RULE_TIME_PER_DAY,
            0)
    def test_min_break_time(self):

        reference_time = datetime.datetime.utcnow()
        rule_set = TestRuleHandler.create_dummy_ruleset_config()

        previous_activity_start = reference_time + datetime.timedelta(seconds=-1200)
        previous_activity_end = previous_activity_start + datetime.timedelta(seconds=600)

        previous_activity = process_statistics.Activity(p_start_time=previous_activity_start)
        previous_activity.set_end_time(previous_activity_end)

        previous_short_activity_end = previous_activity_start + datetime.timedelta(seconds=200)
        previous_short_activity = process_statistics.Activity(p_start_time=previous_activity_start)
        previous_short_activity.set_end_time(previous_short_activity_end)

        rule_set.max_activity_duration = 600

        stat_info = process_statistics.ProcessStatisticsInfo(p_username=USERNAME, p_reference_time=reference_time,
                                                             p_min_activity_duration=MIN_ACTIVITY_DURATION,
                                                             p_max_lookback_in_days=MAX_LOOKBACK_IN_DAYS)

        stat_info.previous_activity = previous_activity

        # Check that playing is not allowed after full break minus one second
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-299)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_set.min_break = 300

        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)

        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, rule_handler.RULE_MIN_BREAK)

        # Check that playing is allowed after full break minus one second but with free_play activated
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-299)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_set.min_break = 300
        rule_set.free_play = True
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, 0)

        # Check that playing is allowed after full break
        rule_set.free_play = False
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-300)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_set.min_break = 300
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, 0)

        # Check that playing is not allowed after break after short period (1/3 of max) minus one second
        stat_info.previous_activity = previous_short_activity
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-99)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, rule_handler.RULE_MIN_BREAK)
        self.assertEqual(rule_result_info.args['break_minutes_left'], 0)

        # Check that playing is not allowed after break after short period (1/3 of max) minus one second
        # but with max_activity_duration=0
        stat_info.previous_activity = previous_short_activity
        rule_result_info = rule_handler.RuleResultInfo()
        rule_set.max_activity_duration = 0
        activity_start_time = reference_time + datetime.timedelta(seconds=-299)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, rule_handler.RULE_MIN_BREAK)

        # Check that playing is allowed after break after short period (1/3 of max)
        # but with max_activity_duration=0
        stat_info.previous_activity = previous_short_activity
        rule_result_info = rule_handler.RuleResultInfo()
        rule_set.max_activity_duration = 0
        activity_start_time = reference_time + datetime.timedelta(seconds=-300)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, 0)

        # Check that playing is allowed after break after short period (1/3 of max)
        stat_info.previous_activity = previous_short_activity
        rule_set.max_activity_duration = 600
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-100)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, 0)

        # Check that playing is not allowed after break after short period (1/3 of max) minus 31 second and
        # that the number of break minutes left = 1
        stat_info.previous_activity = previous_short_activity
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-69)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, rule_handler.RULE_MIN_BREAK)
        self.assertEqual(rule_result_info.args['break_minutes_left'], 1)

        # Check that playing is not allowed after break after short period (1/3 of max) minus 91 second and
        # that the number of break minutes left = 2
        stat_info.previous_activity = previous_short_activity
        rule_result_info = rule_handler.RuleResultInfo()
        activity_start_time = reference_time + datetime.timedelta(seconds=-9)
        stat_info.last_inactivity_start_time = activity_start_time
        rule_handler.RuleHandler.check_min_break(p_rule_set=rule_set, p_stat_info=stat_info,
                                                 p_rule_result_info=rule_result_info)
        self.assertEqual(rule_result_info.applying_rules & rule_handler.RULE_MIN_BREAK, rule_handler.RULE_MIN_BREAK)
        self.assertEqual(rule_result_info.args['break_minutes_left'], 2)