In this challenge, you will focus on making your API requests more reliable by handling errors gracefully. When working with APIs, it is common to encounter issues such as incorrect URLs, network problems, or unexpected responses. Being able to detect these problems and respond appropriately is an essential skill for robust API integrations. Your goal is to request a cat fact from the Cat Facts API. However, if something goes wrong—such as a network failure or an invalid response—your code should print a clear message indicating the failure.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout
import sys

class TestTask(unittest.TestCase):
    def test_successful_cat_fact(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        # Should print a non-empty string that is not the failure message
        _dynamic_test(
            self,
            output.strip() != "" and "failed to retrieve cat fact." not in output,
            "Prints a cat fact when the request is successful.",
            f"Expected a cat fact, got: '{output.strip()}'",
        )

    def test_network_error(self):
        # Patch requests.get to raise a ConnectionError
        import user_code
        import types
        import requests
        import builtins
        
        def fake_get(*args, **kwargs):
            raise requests.exceptions.ConnectionError("Network down")

        real_get = requests.get
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        requests.get = real_get
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on network error.",
            f"Expected failure message, got: '{output.strip()}'",
        )

    def test_invalid_url(self):
        # Change the URL to an invalid one
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        code = code.replace('"https://catfact.ninja/fact"', '"https://invalid-url-for-cat-fact-api.com"')
        ns = {}
        import requests
        import io
        from contextlib import redirect_stdout
        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, ns)
            ns['get_cat_fact']()
        output = normalize_text(f.getvalue())
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on invalid URL.",
            f"Expected failure message, got: '{output.strip()}'",
        )

    def test_invalid_json(self):
        # Patch requests.get to return a response with invalid json
        import user_code
        import requests
        class FakeResponse:
            def raise_for_status(self):
                return None
            def json(self):
                raise ValueError("No JSON")
        def fake_get(*args, **kwargs):
            return FakeResponse()
        real_get = requests.get
        requests.get = fake_get
        import io
        from contextlib import redirect_stdout
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        requests.get = real_get
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on invalid JSON response.",
            f"Expected failure message, got: '{output.strip()}'",
        )

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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how to interact with open APIs using Python, process and analyze data from real-world web services, and build practical applications without the need for registration or payment. This course is designed for intermediate Python learners eager to expand their skills in data retrieval and manipulation using APIs.

Learn the core concepts of APIs, how to make HTTP requests in Python, and how to handle responses from open APIs.

Dive deeper into working with open APIs by retrieving and analyzing public data, such as weather and space information.

Apply advanced techniques for working with APIs, including handling query parameters, processing lists of data, and basic data visualization.

Challenge: Error Handling with APIs

Ratkaisu

Challenge: Error Handling with APIs

Ratkaisu