Svelte Basics

Styling React Components

This is a method for debuggging FastAPI with pdb debugger.



## pdb

[pdb](https://docs.python.org/3/library/pdb.html) is a debugger built right into the python standard library. You don't need to install a library. You don't need a fancy IDE.

## FastAPI

This debugging method should have broad application, but here we will use it in a FastAPI app.

[FastAPI](https://fastapi.tiangolo.com/) is a framework for building web APIs in python. Here's a basic application:

```
from datetime import datetime
from fastapi import FastAPI

app = FastAPI()

@app.get('/')
def root():
    now = datetime.now()
    return { "now": now }
```

There's one endpoint. It returns the current time. 

## Run with uvicorn

[uvicorn](https://www.uvicorn.org/) is an ASGI web server implementation. You can use it to run FastAPI. Install:

```
poetry add uvicorn
```

And start:

```
uvicorn main:app --reload
```

The `main:app` argument is the path to your `app` variable inside the `main.py` module. The `--reload` flag detects changes to the files and restarts the server automatically for dev mode.


If we call it, it works:

```
❯ curl localhost:8000
{"now":"2022-06-02T06:53:58.376421"}%
```

## pdb Debugging

This is all a contrived example. There's not too much to debug. But let's add a breakpoint and try it out. Let's determine what the value of `now` is at runtime.

The breakpoint is added by adding code. You need to import `pdb` and the set the breakpoint. Do that with a one-liner:

```
import pdb; pdb.set_trace()
```

Add that line below the `now` variable assignment:

```
@app.get('/')
def root():
    now = datetime.now()
    import pdb; pdb.set_trace()
    return { "now": now }
```

And stop and restart `uvicorn`, now with a `--debug` flag:

```
uvicorn main:app --reload --debug
```

Then curl to hit the code:

```
❯ curl localhost:8000
```

It'll hang, and the process for `uvicorn` will change from the usually app log to stdout to show a `pdb` repl:

```
> /Users/jaketrent/dev/ohai-fastapi/main.py(10)root()
-> return { "now": now }
(Pdb)
```

It stops on the line of the breakpoint. Here, you can examine the local variables by name. We want to see the value of `now`, so we type:

```
(Pdb) now
datetime.datetime(2022, 6, 2, 8, 2, 50, 139827)
```

And look at that! We see the value at runtime.

At the `(Pdb)` prompt, you can run the usual debugger commands. These are done with text commands. Type `?` to see a list of possible commands:

```
(Pdb) ?

Documented commands (type help <topic>):
========================================
EOF    c          d        h         list      q        rv       undisplay
a      cl         debug    help      ll        quit     s        unt
alias  clear      disable  ignore    longlist  r        source   until
args   commands   display  interact  n         restart  step     up
b      condition  down     j         next      return   tbreak   w
break  cont       enable   jump      p         retval   u        whatis
bt     continue   exit     l         pp        run      unalias  where

Miscellaneous help topics:
==========================
exec  pdb
```

You can run `help` on any of these commands, such as `help c`, and you can see:

```
(Pdb) help c
c(ont(inue))
        Continue execution, only stop when a breakpoint is encountered.
```

Now that we're done debugging, we'll press `c` for continue to move past our breakpoint. At that point, curl returns:

```
{"now":"2022-06-02T08:02:50.139827"}
```

`pdb` is a capable debugger. It doesn't require extra tooling. FastAPI can't keep any secrets from us!

How to debug FastAPI in python with pdb debugger

Debug FastAPI with pdb

How to add a cookie to a curl request.



First, find your cookie. Perhaps you're making a test request to an API that your web app uses. You could fire up the web app, authenticate, open devtools and see the cookie in the request headers. Copy it. Keep it secret. Keep it safe.

Then back to the terminal where you belong:

```
curl --cookie "<cookiename>=<cookievalue>" <url>
```

The notable option is here is `--cookie`. The format of the cookie header is for to send the cookie name, followed by an `=` equal sign, followed by the cookie value.


For example:

```
curl --cookie "myjwt=abc123" http://localhost:8080/my/api
```

Add a Cookie to a Curl

To run an async test in pytest, it must be marked. It can be a pain to mark them all individually. Here's how to mark them all async at once.



## Asynchronous tests

You'd need an asynchronous test for asynchronous code under test. For instance, [Quart](https://pgjones.gitlab.io/quart/) is an app server where all the endpoints are asynchronous.  If you were testing that Quart app, you might create a test like:

```python
from quart import Quart
async def test_thing():
    client = Quart("appname", static_folder=None).test_client()
    response = await client.get("/api/thing")
    assert response.status_code == 200
```

When running `pytest`, the use of `async` and `await` keywords will fail, reporting that a plugin is needed.

## Plugin

The plugin that enables async testing in pytest is [pytest-asyncio](https://pypi.org/project/pytest-asyncio/). To install:

```
poetry add pytest-asyncio
```

Or instead of poetry, use the package manager of your choice.

## Mark individually

Now you'd be able to mark a test individually. In your test file, write:

```python
import pytest

@pytest.mark.asyncio
async def test_1():
    # ...

@pytest.mark.asyncio
async def test_2():
    # ...
```

## Mark all tests async

But if you have many tests in a single module, this can be annoying to repeat the decorator. To [mark all tests in the module async](https://docs.pytest.org/en/6.2.x/example/markers.html#marking-whole-classes-or-modules), you mark a special module-global variable called `pytestmark`. At the top of your test file add:

```python
import pytest

pytestmark = pytest.mark.asyncio
```

Now you have no more need to decorate every test function.

Mark All Tests as Async in pytest

This is what it takes to pass params to pytest fixtures.



## Just Use Functions

Instead of using pytest fixtures, the easier method would be to just create a function that sets up and tears down what you need. Like this:

```python
def test_something():
    my_fixture = setup_something('special sauce')

    # assertion...

    teardown_something(my_fixture)

def setup_something(special_param):
    # setup ...
    return my_fixture_with_special_param

def teardown_something(my_fixture):
    # cleanup my_fixture...
```

The problem with this approach is in the case of assertion failure. In that case, `teardown_something` would be skipped, and cleanup would not happen.

## try/finally in Test?

I didn't actually try this method because it seems like I'm working against/outside the test framework, and the test aesthetics of every test body needing wrapped in `try/finally` feel yucky. But maybe we could ensure `teardown_something` is called with:

```python
def test_something():
    my_fixture = None
    try:
        my_fixture = setup_something('special sauce')

        # assertion...
    finally:
        teardown_something(my_fixture)

def setup_something(special_param):
    # setup ...
    return my_fixture_with_special_param

def teardown_something(my_fixture):
    # cleanup my_fixture...
```

Does this actually work? I haven't tried it yet, but it seems like it should.

## Using pytest Fixtures

Let's try the pytest way. pytest has its own way to set up and tear down fixtures:

```python
import pytest

@pytest.fixture(name="my_fixture")
def setup_something():
    my_fixture = # setup...

    yield my_fixture

    # cleanup my_fixture...

def test_something(my_fixture):
    # assertion...
```

A pytest fixture is created with the `pytest.fixture` decorator. It is identified by name. The thing that the generator function yields is the fixture value. When the generator is resumed, it will have a chance to clean up the fixture. The generator is guaranteed to be resumed, allowing this cleanup, even in the case of assertion failure.

But we have removed a key feature of our fixture in this example. `setup_something` now doesn't take `special_param` any more. We need to re-create a way to allow this parameter using pytest fixtures.

## Params in pytest fixtures

The difficulty lies in the fanciness of how a test function gains access to the fixture. The name of the fixture is passed as a parameter to the test function. pytest uses reflection to load the proper test function. This function invocation happens behind the scenes. We do not invoke the function, so we have difficulty in passing arguments. The way we can get pytest to take a parameter is not pretty, as you will see.

We will accomplish this via markers. [Markers](https://docs.pytest.org/en/7.1.x/example/markers.html) are a pytest concept that usually allows identifying tests to be a part of certain categories (eg, integration tests). But we will use it to pass parameters.

Markers must be registered in order to avoid warnings. This can be done in [pytest.ini or elsewhere](https://docs.pytest.org/en/6.2.x/customize.html#:~:text=Many%20pytest%20settings%20can%20be,or%20in%20your%20tests%20folder):

```
[pytest]
markers =
    my_fixture_data(special_param): param to pass to something fixture
```

The marker is named `my_fixture_data` arbitrarily. In this case, the name is meant to associate it with the `my_fixture` fixture. The `_data` suffix is meant to generally mean that this is a parameter associated with its use.

Then mark the test that uses the fixture:

```python
import pytest

@pytest.mark.my_fixture_data("special sauce")
def test_something(my_fixture):
    # assertion only...
```

The value `"special sauce"` is passed as an argument to the marker function.

Now we must make the fixture itself use the marker:

```python
@pytest.fixture(name="my_fixture")
def setup_something():
    marker = request.node.get_closest_marker("my_fixture_data")
    special_param = marker.args[0]
    my_fixture_with_special_param = # setup ...

    yield my_fixture_with_special_param

    # cleanup my_fixture_with_special_param...
```

From within the test, the closest marker is found. This will be the marker decorating the test function. It's found by name. Then its first argument is accessed. This is the `"special sauce"` value. The setup of the fixture can then use this parameter value.

Convoluted? Yes. Does it work? Yes.

Do you know know of a better way to pass parameters to pytest fixtures? I hope so.

Skill up with a sweet course

Find spicey tips in tech

Debug FastAPI with pdb

Add a Cookie to a Curl

Mark All Tests as Async in pytest

Pass Params to Pytest Fixture