
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_return_structure(self):
        import user_code
        importlib.reload(user_code)
        log_data = """
2024-07-01 10:00:01 INFO System started successfully
2024-07-01 10:01:15 WARNING Disk usage at 85%
2024-07-01 10:02:22 ERROR Failed to connect to database
2024-07-01 10:03:30 INFO User logged in: admin
2024-07-01 10:04:05 ERROR Timeout while waiting for response
2024-07-01 10:05:10 WARNING High memory usage detected
2024-07-01 10:06:12 INFO Scheduled backup completed
2024-07-01 10:07:19 ERROR Unable to write to log file
"""
        result = user_code.parse_log(log_data)
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 4,
            "Function returns a tuple with four elements",
            f"Expected tuple of length 4, got {type(result)} with length {len(result) if isinstance(result, tuple) else 'N/A'}",
        )

    def test_error_lines_content(self):
        import user_code
        importlib.reload(user_code)
        log_data = """
2024-07-01 10:00:01 INFO System started successfully
2024-07-01 10:01:15 WARNING Disk usage at 85%
2024-07-01 10:02:22 ERROR Failed to connect to database
2024-07-01 10:03:30 INFO User logged in: admin
2024-07-01 10:04:05 ERROR Timeout while waiting for response
2024-07-01 10:05:10 WARNING High memory usage detected
2024-07-01 10:06:12 INFO Scheduled backup completed
2024-07-01 10:07:19 ERROR Unable to write to log file
"""
        expected_errors = [
            "2024-07-01 10:02:22 ERROR Failed to connect to database",
            "2024-07-01 10:04:05 ERROR Timeout while waiting for response",
            "2024-07-01 10:07:19 ERROR Unable to write to log file",
        ]
        result = user_code.parse_log(log_data)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and isinstance(result[3], list),
            "Fourth element is a list of error lines",
            "Fourth element of return value is not a list of error lines",
        )
        _dynamic_test(
            self,
            result[3] == expected_errors,
            "List of error lines matches expected output",
            f"Expected error lines: {expected_errors}, got: {result[3]}",
        )

    def test_counts_are_correct(self):
        import user_code
        importlib.reload(user_code)
        log_data = """
2024-07-01 10:00:01 INFO System started successfully
2024-07-01 10:01:15 WARNING Disk usage at 85%
2024-07-01 10:02:22 ERROR Failed to connect to database
2024-07-01 10:03:30 INFO User logged in: admin
2024-07-01 10:04:05 ERROR Timeout while waiting for response
2024-07-01 10:05:10 WARNING High memory usage detected
2024-07-01 10:06:12 INFO Scheduled backup completed
2024-07-01 10:07:19 ERROR Unable to write to log file
"""
        result = user_code.parse_log(log_data)
        _dynamic_test(
            self,
            result is not None and result[0] == 3 and result[1] == 2 and result[2] == 3,
            "Counts for ERROR, WARNING, and INFO are correct",
            f"Expected ERROR=3, WARNING=2, INFO=3, got ERROR={result[0]}, WARNING={result[1]}, INFO={result[2]}",
        )

    def test_empty_log(self):
        import user_code
        importlib.reload(user_code)
        log_data = """"""
        result = user_code.parse_log(log_data)
        _dynamic_test(
            self,
            result is not None and result[0] == 0 and result[1] == 0 and result[2] == 0 and result[3] == [],
            "Handles empty log correctly",
            f"Expected (0, 0, 0, []), got {result}",
        )

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: Parse and Summarize Log Data

Løsning