Visualizing resource trends is a key skill for anticipating system needs and planning capacity upgrades. By plotting resource usage data—like memory consumption—over time, you can quickly spot spikes, patterns, and potential bottlenecks. This challenge asks you to create a Python script that uses the `matplotlib` library to plot memory usage from a hardcoded list, label the axes, and add a descriptive title. This kind of visualization is essential for DevOps professionals who need to monitor systems and plan for future growth.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import types
from unittest import mock
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code
        self.memory_usage = [512, 530, 545, 600, 620, 610, 590, 650, 670, 680]

    def test_plot_called_with_correct_data(self):
        import user_code
        importlib.reload(user_code)
        with mock.patch("matplotlib.pyplot.plot") as mock_plot:
            user_code.plot_memory_usage(self.memory_usage)
            called = mock_plot.called
            args, kwargs = mock_plot.call_args if mock_plot.call_args else ((), {})
            correct_x = list(range(len(self.memory_usage)))
            correct_y = self.memory_usage
            _dynamic_test(
                self,
                called and list(args[0]) == correct_x and list(args[1]) == correct_y,
                "plot() called with correct x and y data",
                f"plot() not called with correct x and y. Got: {args}"
            )

    def test_x_axis_label(self):
        import user_code
        importlib.reload(user_code)
        with mock.patch("matplotlib.pyplot.show"):
            user_code.plot_memory_usage(self.memory_usage)
            xlabel = plt.gca().get_xlabel()
            _dynamic_test(
                self,
                xlabel == "Time (minutes)",
                "X-axis label is correctly set to 'Time (minutes)'",
                f"Expected x-axis label 'Time (minutes)', got '{xlabel}'"
            )

    def test_y_axis_label(self):
        import user_code
        importlib.reload(user_code)
        with mock.patch("matplotlib.pyplot.show"):
            user_code.plot_memory_usage(self.memory_usage)
            ylabel = plt.gca().get_ylabel()
            _dynamic_test(
                self,
                ylabel == "Memory Usage (MB)",
                "Y-axis label is correctly set to 'Memory Usage (MB)'",
                f"Expected y-axis label 'Memory Usage (MB)', got '{ylabel}'"
            )

    def test_plot_title(self):
        import user_code
        importlib.reload(user_code)
        with mock.patch("matplotlib.pyplot.show"):
            user_code.plot_memory_usage(self.memory_usage)
            title = plt.gca().get_title()
            _dynamic_test(
                self,
                title == "Memory Usage Over Time",
                "Plot title is correctly set to 'Memory Usage Over Time'",
                f"Expected plot title 'Memory Usage Over Time', got '{title}'"
            )

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
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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: Resource Usage Grapher

Solution

Challenge: Resource Usage Grapher

Solution