Summary  
This chapter explains how to use the various assert methods in unittest.TestCase—such as assertEqual, assertTrue, assertIn, and assertRaises—to validate expected outcomes and errors in code.  

General domain of usage  
automated testing

`assert`-metoderne er en del af `unittest.TestCase`-klassen og bruges til at kontrollere betingelser i dine tests.
Kort sagt afsluttes hver testmetode i Test-klassen med en erklæring som `self.assert`.

## Almindeligt anvendte assert-metoder
| **Method** | **Check** | **Example** |
|--------------|-------|-------------|
| assertEqual(a, b) | a == b | assertEqual(sum([1, 2, 3]), 6) |
| assertNotEqual(a, b) | a != b | assertNotEqual(1, 2) |
| assertTrue(x) | bool(x) er True | assertTrue(isinstance(123, int)) |
| assertFalse(x) | bool(x) er False | assertFalse(isinstance("hello", int)) |
| assertIs(a, b) | a er b | a = 1, b = a |
| assertIsNone(x) | x er None | book.price = None |
| assertIn(a, b) | a i b | assertIn(2, [1, 2, 3]) |
| assertIsInstance(a, b) | isinstance(a, b) | assertIsInstance(123, int) |

Desuden bruges `assertRaises(Error, func, *args, **kwargs)` til at teste, at en fejl bliver udløst. For eksempel:
``` python
with self.assertRaises(ValueError):
    int("xyz")
```
Dette kontrollerer, at konvertering af "xyz" til et heltal udløser `ValueError`.


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

class TestTask(unittest.TestCase):
    def test_add_equal(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        _dynamic_test(self, test_class is not None, "TestFunctions class exists", "TestFunctions class not found")
        test_method = getattr(test_class, 'test_add_equal', None)
        _dynamic_test(self, callable(test_method), "test_add_equal method exists", "test_add_equal method missing")
        test_case = test_class('test_add_equal')
        try:
            test_case.test_add_equal()
            _dynamic_test(self, True, "add(2, 3) == 5 passes assertEqual", "add(2, 3) == 5 failed assertEqual")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(2, 3) == 5 failed assertEqual: {e}")

    def test_add_not_equal(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_add_not_equal', None)
        _dynamic_test(self, callable(test_method), "test_add_not_equal method exists", "test_add_not_equal method missing")
        test_case = test_class('test_add_not_equal')
        try:
            test_case.test_add_not_equal()
            _dynamic_test(self, True, "add(2, 2) != 5 passes assertNotEqual", "add(2, 2) != 5 failed assertNotEqual")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(2, 2) != 5 failed assertNotEqual: {e}")

    def test_is_even_true(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_is_even_true', None)
        _dynamic_test(self, callable(test_method), "test_is_even_true method exists", "test_is_even_true method missing")
        test_case = test_class('test_is_even_true')
        try:
            test_case.test_is_even_true()
            _dynamic_test(self, True, "is_even(4) is True passes assertTrue", "is_even(4) is True failed assertTrue")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"is_even(4) is True failed assertTrue: {e}")

    def test_is_even_false(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_is_even_false', None)
        _dynamic_test(self, callable(test_method), "test_is_even_false method exists", "test_is_even_false method missing")
        test_case = test_class('test_is_even_false')
        try:
            test_case.test_is_even_false()
            _dynamic_test(self, True, "is_even(5) is False passes assertFalse", "is_even(5) is False failed assertFalse")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"is_even(5) is False failed assertFalse: {e}")

    def test_get_item_is(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_get_item_is', None)
        _dynamic_test(self, callable(test_method), "test_get_item_is method exists", "test_get_item_is method missing")
        test_case = test_class('test_get_item_is')
        try:
            test_case.test_get_item_is()
            _dynamic_test(self, True, "get_item([10, 20, 30], 1) is 20 passes assertIs", "get_item([10, 20, 30], 1) is 20 failed assertIs")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"get_item([10, 20, 30], 1) is 20 failed assertIs: {e}")

    def test_get_item_is_none(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_get_item_is_none', None)
        _dynamic_test(self, callable(test_method), "test_get_item_is_none method exists", "test_get_item_is_none method missing")
        test_case = test_class('test_get_item_is_none')
        try:
            test_case.test_get_item_is_none()
            _dynamic_test(self, True, "get_item([1,2,3], 10) is None passes assertIsNone", "get_item([1,2,3], 10) is None failed assertIsNone")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"get_item([1,2,3], 10) is None failed assertIsNone: {e}")

    def test_in_list(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_in_list', None)
        _dynamic_test(self, callable(test_method), "test_in_list method exists", "test_in_list method missing")
        test_case = test_class('test_in_list')
        try:
            test_case.test_in_list()
            _dynamic_test(self, True, "2 in [1,2,3] passes assertIn", "2 in [1,2,3] failed assertIn")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"2 in [1,2,3] failed assertIn: {e}")

    def test_add_is_instance(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_add_is_instance', None)
        _dynamic_test(self, callable(test_method), "test_add_is_instance method exists", "test_add_is_instance method missing")
        test_case = test_class('test_add_is_instance')
        try:
            test_case.test_add_is_instance()
            _dynamic_test(self, True, "add(1,2) is int passes assertIsInstance", "add(1,2) is int failed assertIsInstance")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(1,2) is int failed assertIsInstance: {e}")

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

Du vil opnå praktiske færdigheder i Pythons moduler og imports for effektiv kodestyring. Behersk avancerede teknikker til fejlhåndtering for mere pålidelige applikationer, automatiser filoperationer med filhåndtering, og lær robuste teststrategier med Pytest og Unittest for at sikre din kodes integritet.

Hvis du oplever frustration over import-sætninger, forskellen mellem moduler og biblioteker eller håndtering af din Python-projektstruktur, er dette afsnit din nøgle til klarhed.

Ønsker du at fejlfinde din kode effektivt og forstå styrken ved at udnytte forskellige fejl? Dette afsnit afmystificerer fejlhåndtering i Python og viser, hvorfor det er afgørende for udviklere at mestre disse færdigheder for robuste applikationer.

Ønsker du at automatisere filoperationer i dine projekter? Dette afsnit går i dybden med det grundlæggende i filhåndtering i Python og giver dig værktøjerne til effektivt at læse, skrive og administrere filer for mere smidige og kraftfulde applikationer.

Du vil lære detaljerne i testning med Pytest og grundprincipperne i Test-Driven Development (TDD). Dette afsnit guider dig gennem oprettelse af robuste tests, der øger din kodes pålidelighed og effektiviserer din udviklingsproces.

Behersk automatiseret testning med Unittest. Lær at dække forskellige testtilfælde effektivt ved hjælp af setup, teardown og mocking.

I Python er iteratorer og generatorer centrale begreber, der muliggør effektiv og hukommelsesvenlig databehandling. Hvor iteratorer følger en specifik protokol for sekventiel adgang til data, forenkler generatorer iteration ved at producere værdier efter behov med yield-nøgleordet. Dette afsnit udforsker disse begreber og deres praktiske anvendelser og hjælper dig med at mestre hukommelseseffektiv programmering.

Brug af Assert-metoder i Unittest: Validering af Testresultater

Almindeligt anvendte assert-metoder

Løsning

Method	Check	Example
assertEqual(a, b)	a == b	assertEqual(sum([1, 2, 3]), 6)
assertNotEqual(a, b)	a != b	assertNotEqual(1, 2)
assertTrue(x)	bool(x) er True	assertTrue(isinstance(123, int))
assertFalse(x)	bool(x) er False	assertFalse(isinstance("hello", int))
assertIs(a, b)	a er b	a = 1, b = a
assertIsNone(x)	x er None	book.price = None
assertIn(a, b)	a i b	assertIn(2, [1, 2, 3])
assertIsInstance(a, b)	isinstance(a, b)	assertIsInstance(123, int)