
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)
        self.func = getattr(user_code, 'visualize_test_outcomes', None)

    def test_passed_count(self):
        test_results = {
            'a': 'passed', 'b': 'failed', 'c': 'passed', 'd': 'failed', 'e': 'passed'
        }
        called = {'called': False}
        orig_bar = plt.bar
        orig_show = plt.show
        def fake_bar(labels, counts, color=None):
            called['called'] = True
            self.labels = labels
            self.counts = counts
            self.color = color
            return None
        plt.bar = fake_bar
        plt.show = lambda: None
        if self.func:
            self.func(test_results)
            _dynamic_test(
                self,
                hasattr(self, 'counts') and self.counts[0] == 3,
                "Counts correct number of 'passed' tests (3)",
                f"Expected 3 passed, got {getattr(self, 'counts', [None, None])[0]}"
            )
        else:
            _dynamic_test(self, False, '', 'Function visualize_test_outcomes not implemented')
        plt.bar = orig_bar
        plt.show = orig_show

    def test_failed_count(self):
        test_results = {
            'a': 'failed', 'b': 'failed', 'c': 'passed', 'd': 'failed', 'e': 'passed'
        }
        called = {'called': False}
        orig_bar = plt.bar
        orig_show = plt.show
        def fake_bar(labels, counts, color=None):
            called['called'] = True
            self.labels = labels
            self.counts = counts
            self.color = color
            return None
        plt.bar = fake_bar
        plt.show = lambda: None
        if self.func:
            self.func(test_results)
            _dynamic_test(
                self,
                hasattr(self, 'counts') and self.counts[1] == 3,
                "Counts correct number of 'failed' tests (3)",
                f"Expected 3 failed, got {getattr(self, 'counts', [None, None])[1]}"
            )
        else:
            _dynamic_test(self, False, '', 'Function visualize_test_outcomes not implemented')
        plt.bar = orig_bar
        plt.show = orig_show

    def test_bar_chart_labels(self):
        test_results = {
            'x': 'passed', 'y': 'failed', 'z': 'failed'
        }
        orig_bar = plt.bar
        orig_xlabel = plt.xlabel
        orig_ylabel = plt.ylabel
        orig_title = plt.title
        orig_show = plt.show
        labels_captured = {}
        def fake_bar(labels, counts, color=None):
            labels_captured['labels'] = labels
            labels_captured['counts'] = counts
            labels_captured['color'] = color
            return None
        xlabel_text = {}
        ylabel_text = {}
        title_text = {}
        plt.bar = fake_bar
        plt.xlabel = lambda x: xlabel_text.setdefault('xlabel', x)
        plt.ylabel = lambda x: ylabel_text.setdefault('ylabel', x)
        plt.title = lambda x: title_text.setdefault('title', x)
        plt.show = lambda: None
        if self.func:
            self.func(test_results)
            _dynamic_test(
                self,
                'labels' in labels_captured and labels_captured['labels'] == ['Passed', 'Failed'],
                "Bar chart labels are ['Passed', 'Failed']",
                f"Expected labels ['Passed', 'Failed'], got {labels_captured.get('labels')}"
            )
            _dynamic_test(
                self,
                xlabel_text.get('xlabel') == 'Test Outcome',
                "X-axis labeled as 'Test Outcome'",
                f"Expected x-label 'Test Outcome', got '{xlabel_text.get('xlabel')}'"
            )
            _dynamic_test(
                self,
                ylabel_text.get('ylabel') == 'Number of Tests',
                "Y-axis labeled as 'Number of Tests'",
                f"Expected y-label 'Number of Tests', got '{ylabel_text.get('ylabel')}'"
            )
            _dynamic_test(
                self,
                title_text.get('title') == 'Test Suite Outcomes',
                "Chart title is 'Test Suite Outcomes'",
                f"Expected title 'Test Suite Outcomes', got '{title_text.get('title')}'"
            )
        else:
            _dynamic_test(self, False, '', 'Function visualize_test_outcomes not implemented')
        plt.bar = orig_bar
        plt.xlabel = orig_xlabel
        plt.ylabel = orig_ylabel
        plt.title = orig_title
        plt.show = orig_show

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

Master Python as a powerful tool for automation engineering. This course guides you through practical and advanced Python techniques to automate repetitive tasks, analyze data, and interact with systems, all tailored for automation engineers. Each section blends engaging theory with hands-on, real-world challenges.

Learn how Python can automate repetitive and time-consuming tasks commonly faced by automation engineers, from log parsing to report generation.

Dive into data manipulation and analysis using Python and pandas, tailored for automation engineers handling structured data.

Master Python techniques for interacting with systems, automating tests, and analyzing results—core skills for automation engineers.

Challenge: Visualize Test Suite Outcomes

Soluzione