You are working with the public API `jsonplaceholder.typicode.com`, which provides fake data for testing and learning. Your task is to fetch user information and display it in a readable format.

The endpoint `https://jsonplaceholder.typicode.com/users/{user_id}` returns a JSON object with the following fields:

- `name`: the user's full name;
- `email`: the user's email address;
- `company`: an object with a `name` field containing the company name.


import unittest
import asyncio
import re

# Helper function to dynamically generate test names and assertions
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)


class TestUserCode(unittest.TestCase):

    def test_fetch_user_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "fetch_user"),
            "The `fetch_user` function is declared.",
            "Expected `fetch_user` to be declared."
        )

    def test_fetch_user_is_coroutine(self):
        import user_code
        _dynamic_test(
            self,
            asyncio.iscoroutinefunction(user_code.fetch_user),
            "The `fetch_user` function is a coroutine (defined with `async def`).",
            "Expected `fetch_user` to be defined with `async def`."
        )

    def test_main_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "main"),
            "The `main` function is declared.",
            "Expected `main` to be declared."
        )

    def test_main_is_coroutine(self):
        import user_code
        _dynamic_test(
            self,
            asyncio.iscoroutinefunction(user_code.main),
            "The `main` function is a coroutine (defined with `async def`).",
            "Expected `main` to be defined with `async def`."
        )

    def test_gather_is_used(self):
        with open("user_code.py", "r") as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r"asyncio\.gather\s*\(", user_code_source),
            "`asyncio.gather()` is used in `main()`.",
            "Expected `asyncio.gather()` to be used to fetch users concurrently."
        )

    def test_all_three_users_fetched(self):
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        has_user_1 = re.search(r"fetch_user\s*\(.*,\s*1\s*\)", user_code_source)
        has_user_2 = re.search(r"fetch_user\s*\(.*,\s*2\s*\)", user_code_source)
        has_user_3 = re.search(r"fetch_user\s*\(.*,\s*3\s*\)", user_code_source)

        _dynamic_test(
            self,
            bool(has_user_1 and has_user_2 and has_user_3),
            "`fetch_user` is called for user IDs `1`, `2`, and `3`.",
            "Expected `fetch_user` to be called for user IDs `1`, `2`, and `3`."
        )


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

test_main.py

Master the skills needed to build efficient, concurrent Python applications using asyncio – from coroutines and event loop fundamentals through tasks, synchronization primitives, and real-world debugging techniques.

Gain a solid understanding of asynchronous programming concepts and the core mechanisms behind Python's asyncio library.

Dive into asyncio's task scheduling mechanisms and learn how to run multiple coroutines concurrently.

Get hands-on experience with HTTP clients, synchronization primitives, and queue-based pipelines using asyncio.

Explore advanced asyncio features for controlling task groups, running blocking code, and debugging asynchronous applications.

Challenge: Your First Async Function

Solution