
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = pd.DataFrame({
            'campaign': ['A', 'B', 'C'],
            'impressions': [1000, 2000, 1500],
            'clicks': [100, 200, 150],
            'conversions': [10, 40, 15],
            'spend': [50, 120, 75]
        })

    def _get_summary(self, data):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_campaigns(data.copy())
        output = f.getvalue()
        return output

    def test_conversion_rate_column(self):
        # Check conversion_rate column is correct
        df = self.data.copy()
        import user_code
        importlib.reload(user_code)
        user_code.summarize_campaigns(df)
        expected = list(df['conversions'] / df['clicks'])
        actual = list(df['conversion_rate']) if 'conversion_rate' in df else None
        _dynamic_test(
            self,
            actual is not None and all(abs(a - e) < 1e-8 for a, e in zip(actual, expected)),
            "Conversion rate column is calculated correctly.",
            f"Conversion rate column incorrect. Got: {actual}, Expected: {expected}"
        )

    def test_roi_column(self):
        # Check ROI column is correct
        df = self.data.copy()
        import user_code
        importlib.reload(user_code)
        user_code.summarize_campaigns(df)
        expected = list((df['conversions'] * 100 - df['spend']) / df['spend'])
        actual = list(df['roi']) if 'roi' in df else None
        _dynamic_test(
            self,
            actual is not None and all(abs(a - e) < 1e-8 for a, e in zip(actual, expected)),
            "ROI column is calculated correctly.",
            f"ROI column incorrect. Got: {actual}, Expected: {expected}"
        )

    def test_top_campaign_indicator(self):
        # Check only the highest conversion rate campaign is marked
        df = self.data.copy()
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_campaigns(df)
        output = f.getvalue()
        # The highest conversion rate is for campaign B (40/200 = 0.2), then C (15/150=0.1), then A (10/100=0.1)
        _dynamic_test(
            self,
            '<< TOP CAMPAIGN' in output,
            "Top campaign indicator is present in output.",
            "Top campaign indicator not found in output."
        )
        # Ensure only one campaign is marked
        count = output.count('<< TOP CAMPAIGN')
        _dynamic_test(
            self,
            count == 1,
            "Only one campaign is marked as top.",
            f"Expected only one top campaign, found: {count}"
        )
        # Ensure it is for campaign B
        lines = [l for l in output.splitlines() if '<< TOP CAMPAIGN' in l]
        _dynamic_test(
            self,
            any('B' in l for l in lines),
            "Top campaign indicator is for correct campaign.",
            f"Top campaign indicator is not for campaign B: {lines}"
        )

    def test_varied_input(self):
        # Test with different campaign names and data
        df = pd.DataFrame({
            'campaign': ['X', 'Y'],
            'impressions': [5000, 10000],
            'clicks': [250, 400],
            'conversions': [50, 80],
            'spend': [200, 350]
        })
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_campaigns(df)
        output = f.getvalue()
        # Conversion rates: X=0.2, Y=0.2, both equal
        _dynamic_test(
            self,
            'conversion_rate' in output and 'roi' in output,
            "Summary table includes conversion_rate and roi columns.",
            "Summary table missing conversion_rate or roi columns."
        )
        # Should mark only one as top campaign
        count = output.count('<< TOP CAMPAIGN')
        _dynamic_test(
            self,
            count == 1,
            "Only one campaign is marked as top when multiple have same conversion rate.",
            f"Expected one top campaign, found: {count}"
        )

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

Advance your Python automation skills by learning to generate analytical summaries, business reports, and visual dashboards automatically. This course guides you through practical workflows for automating data analysis, reporting, and visualization tasks using Python, pandas, matplotlib, and seaborn.

Learn to automate the generation of analytical summaries, business reports, and visual dashboards using Python. Alternate between concept introduction and hands-on automation tasks for real-world reporting scenarios.

Challenge: Summarize Campaign Performance

Oplossing