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

Metoderna `assert` är en del av klassen `unittest.TestCase` och används för att kontrollera villkor i dina tester.
Enkelt uttryckt avslutas varje testmetod i Test-klassen med ett påstående som `self.assert`.

## Vanligt förekommande 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) is True | assertTrue(isinstance(123, int)) |
| assertFalse(x) | bool(x) is False | assertFalse(isinstance("hello", int)) |
| assertIs(a, b) | a is b | a = 1, b = a |
| assertIsNone(x) | x is None | book.price = None |
| assertIn(a, b) | a in b | assertIn(2, [1, 2, 3]) |
| assertIsInstance(a, b) | isinstance(a, b) | assertIsInstance(123, int) |

Dessutom används `assertRaises(Error, func, *args, **kwargs)` för att testa att ett fel uppstår. Till exempel:
``` python
with self.assertRaises(ValueError):
    int("xyz")
```
Detta kontrollerar att konvertering av "xyz" till integer utlö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 kommer att förvärva praktiska färdigheter i Pythons moduler och importer för effektiv kodhantering. Behärska avancerade tekniker för felhantering för mer tillförlitliga applikationer, automatisera filoperationer med filhantering och lär dig robusta teststrategier med Pytest och Unittest för att säkerställa kodens integritet.

Om du känner dig frustrerad över import-satser, skillnaden mellan moduler och bibliotek eller hanteringen av din Python-projektstruktur, är detta avsnitt din nyckel till klarhet.

Vill du felsöka din kod effektivt och förstå styrkan i att hantera olika fel? Denna sektion avmystifierar felhantering i Python och visar varför det är avgörande för utvecklare att behärska dessa färdigheter för robusta applikationer.

Vill du automatisera filoperationer i dina projekt? Detta avsnitt går igenom grunderna i filhantering i Python och ger dig verktygen för att läsa, skriva och hantera filer effektivt för smidigare och kraftfullare applikationer.

Du kommer att lära dig allt om testning med Pytest och grunderna i testdriven utveckling (TDD). Detta avsnitt vägleder dig genom att skapa robusta tester som förbättrar kodens tillförlitlighet och effektiviserar din utvecklingsprocess.

Bemästra automatiserad testning med Unittest. Lär dig att täcka olika testfall effektivt med hjälp av setup, teardown och mocking.

I Python är iteratorer och generatorer centrala begrepp som möjliggör effektiv och minnessnål databehandling. Iteratorer följer ett specifikt protokoll för sekventiell åtkomst av data, medan generatorer förenklar iteration genom att producera värden vid behov med nyckelordet yield. Detta avsnitt utforskar dessa begrepp och deras praktiska tillämpningar, vilket hjälper dig att bemästra minnesoptimerad programmering.

Använda Assert-metoder i Unittest: Validering av Testresultat

Vanligt förekommande 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) is True	assertTrue(isinstance(123, int))
assertFalse(x)	bool(x) is False	assertFalse(isinstance("hello", int))
assertIs(a, b)	a is b	a = 1, b = a
assertIsNone(x)	x is None	book.price = None
assertIn(a, b)	a in b	assertIn(2, [1, 2, 3])
assertIsInstance(a, b)	isinstance(a, b)	assertIsInstance(123, int)