In DevOps, maintaining high service uptime is a top priority, as even short outages can impact users and business operations. Being able to quickly analyze and identify servers that are underperforming helps you take proactive steps to ensure reliability. In this challenge, you will use your skills with **pandas DataFrames** to process and interpret service uptime data, making it easier to spot issues before they escalate.

import unittest
import importlib
import ast
import re
import sys
import io

import user_code


class TestTask(unittest.TestCase):
    def _capture(self, func, *args, **kwargs):
        buf = io.StringIO()
        old = sys.stdout
        sys.stdout = buf
        try:
            func(*args, **kwargs)
        finally:
            sys.stdout = old
        return normalize_text(buf.getvalue())

    def test_average_uptime_calculation(self):
        importlib.reload(user_code)
        data = [
            {"server": "A", "uptime_hours": 98},
            {"server": "B", "uptime_hours": 120},
            {"server": "C", "uptime_hours": 85},
            {"server": "D", "uptime_hours": 110},
            {"server": "E", "uptime_hours": 77},
        ]
        threshold = 90
        expected_avg = (98 + 120 + 85 + 110 + 77) / 5

        output = self._capture(user_code.analyze_uptime, data, threshold)
        avg_line = normalize_text(f"Average uptime across servers: {expected_avg:.2f} hours")

        _dynamic_test(
            self,
            avg_line in output,
            "Correctly calculates average uptime.",
            f"Expected average uptime line: '{avg_line}' not found in output: '{output}'",
        )

    def test_identifies_underperforming_servers(self):
        importlib.reload(user_code)
        data = [
            {"server": "A", "uptime_hours": 98},
            {"server": "B", "uptime_hours": 120},
            {"server": "C", "uptime_hours": 85},
            {"server": "D", "uptime_hours": 110},
            {"server": "E", "uptime_hours": 77},
        ]
        threshold = 90

        output = self._capture(user_code.analyze_uptime, data, threshold)

        # After normalize_text(), multiple spaces collapse to one.
        # So check using single-space patterns.
        _dynamic_test(
            self,
            "c 85" in output and "e 77" in output,
            "Correctly identifies all underperforming servers.",
            f"Expected underperforming servers C (85) and E (77) in output. Got: {output}",
        )

    def test_does_not_list_servers_above_threshold(self):
        importlib.reload(user_code)
        data = [
            {"server": "A", "uptime_hours": 98},
            {"server": "B", "uptime_hours": 120},
            {"server": "C", "uptime_hours": 85},
            {"server": "D", "uptime_hours": 110},
            {"server": "E", "uptime_hours": 77},
        ]
        threshold = 90

        output = self._capture(user_code.analyze_uptime, data, threshold)

        _dynamic_test(
            self,
            ("a 98" not in output) and ("b 120" not in output) and ("d 110" not in output),
            "Does not list servers above or equal to threshold as underperforming.",
            f"Found servers above threshold in underperforming list: {output}",
        )

    def test_all_servers_meet_threshold(self):
        importlib.reload(user_code)
        data = [
            {"server": "A", "uptime_hours": 98},
            {"server": "B", "uptime_hours": 120},
            {"server": "C", "uptime_hours": 95},
            {"server": "D", "uptime_hours": 110},
            {"server": "E", "uptime_hours": 100},
        ]
        threshold = 90

        output = self._capture(user_code.analyze_uptime, data, threshold)

        _dynamic_test(
            self,
            "all servers meet or exceed the uptime threshold" in output,
            "Correctly handles case where all servers meet or exceed threshold.",
            f"Expected message for all servers meeting threshold not found in output: {output}",
        )


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()


def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = " " * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i + 1:]:
            if hasattr(next_node, "lineno"):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line + 1:next_line] = []
        changed = True

    return "\\n".join(lines) if changed else code


if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how Python empowers DevOps workflows, automates repetitive tasks, and streamlines infrastructure management. This course introduces practical Python techniques and libraries for DevOps beginners, focusing on automation, monitoring, and data-driven decision-making.

Explore how Python can automate repetitive DevOps tasks, from simple scripting to basic process management.

Learn how Python can be used to monitor system health and analyze logs, providing valuable insights for DevOps teams.

Apply Python's data analysis and visualization capabilities to make informed decisions in DevOps environments.

Challenge: Service Uptime Analyzer

解答