Understanding which types of incidents occur most frequently is crucial for effective DevOps operations. By visualizing incident data, you can quickly identify which areas—such as network, application, or hardware—require the most attention and resources. This challenge will help you practice using Python and seaborn to turn raw incident records into actionable insights, making it easier to prioritize system improvements.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import user_code
from unittest.mock import patch
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)

    def test_count_frequencies(self):
        # Patch plt.show to prevent plot window from blocking
        with patch('matplotlib.pyplot.show'):
            data = {
                "incident_type": [
                    "network", "application", "hardware", "network", "application",
                    "network", "hardware", "application", "network", "hardware",
                    "application", "application", "hardware", "network", "hardware"
                ]
            }
            df = pd.DataFrame(data)
            expected_counts = df["incident_type"].value_counts().to_dict()
            # Run the function and capture the barplot data
            # We'll patch sns.barplot to intercept the call and check data passed
            with patch('seaborn.barplot') as mock_barplot:
                user_code.visualize_incident_frequencies()
                # Check if barplot was called with a DataFrame containing correct counts
                called_args, called_kwargs = mock_barplot.call_args
                plot_data = called_kwargs.get('data')
                x_name = called_kwargs.get('x')
                y_name = called_kwargs.get('y')
                _dynamic_test(
                    self,
                    plot_data is not None and x_name == 'incident_type' and y_name == 'count',
                    "Barplot called with correct x and y axis names.",
                    f"Expected x='incident_type' and y='count', got x='{x_name}', y='{y_name}'."
                )
                # Check that the counts match
                if plot_data is not None:
                    actual_counts = dict(zip(plot_data['incident_type'], plot_data['count']))
                    _dynamic_test(
                        self,
                        actual_counts == expected_counts,
                        "Incident frequencies are counted correctly.",
                        f"Expected counts: {expected_counts}, got: {actual_counts}"
                    )

    def test_labels_and_title(self):
        # Patch plt.show to prevent plot window from blocking
        with patch('matplotlib.pyplot.show'):
            with patch('seaborn.barplot') as mock_barplot:
                # Mock the return value of sns.barplot to a mock object
                mock_plot = unittest.mock.Mock()
                mock_barplot.return_value = mock_plot
                user_code.visualize_incident_frequencies()
                # Check if set_xlabel, set_ylabel, set_title are called
                xlabel_called = mock_plot.set_xlabel.called
                ylabel_called = mock_plot.set_ylabel.called
                title_called = mock_plot.set_title.called
                xlabel_args = mock_plot.set_xlabel.call_args[0][0] if xlabel_called else None
                ylabel_args = mock_plot.set_ylabel.call_args[0][0] if ylabel_called else None
                title_args = mock_plot.set_title.call_args[0][0] if title_called else None
                _dynamic_test(
                    self,
                    xlabel_called and ylabel_called and title_called,
                    "Plot axis labels and title are set.",
                    "Expected axis labels and title to be set on the plot."
                )
                _dynamic_test(
                    self,
                    xlabel_args == 'Incident Type',
                    "X-axis label is correct.",
                    f"Expected x-axis label 'Incident Type', got '{xlabel_args}'"
                )
                _dynamic_test(
                    self,
                    ylabel_args == 'Frequency',
                    "Y-axis label is correct.",
                    f"Expected y-axis label 'Frequency', got '{ylabel_args}'"
                )
                _dynamic_test(
                    self,
                    title_args == 'Incident Frequency by Type',
                    "Plot title is correct.",
                    f"Expected title 'Incident Frequency by Type', got '{title_args}'"
                )

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: Incident Frequency Visualizer

Solution