app = FastAPI(
    servers=[
        {"url": "/", "description": "Default, relative server"},
        {
            "url": "http://staging.localhost.tiangolo.com:8000",
            "description": "Staging but actually localhost still",
        },
        {"url": "https://prod.example.com"},
    ]
)


@app.get("/foo")
def foo():
    return {"message": "Hello World"}


client = TestClient(app)

	}

	result2 := msgUnPath("/skydns/local/cluster/staging/service")
	if result2 != "service.staging.cluster.local.skydns" {
		t.Errorf("Failure to get domain from etcd key (without trailing '/'), expect: 'service.staging.cluster.local.' actually get: '%s'", result2)
	}

	result3 := msgUnPath("/singleleveldomain/")

```

////

The last `CommonQueryParams`, in:

```Python
... Depends(CommonQueryParams)
```

...is what **FastAPI** will actually use to know what is the dependency.

It is from this one that FastAPI will extract the declared parameters and that is what FastAPI will actually call.

---

In this case, the first `CommonQueryParams`, in:

//// tab | Python 3.10+

```Python

	returningRe := regexp.MustCompile(`(?i)RETURNING "id"`)
	actually = returningRe.ReplaceAllString(actually, ``)
	expected = returningRe.ReplaceAllString(expected, ``)

	actually = strings.TrimSpace(actually)
	expected = strings.TrimSpace(expected)

	if actually != expected {
		t.Fatalf("\nexpected: %s\nactually: %s", expected, actually)
	}
}

func replaceQuoteInSQL(sql string) string {

### `scope` { #scope }

The spec also says that the client can send another form field "`scope`".

The form field name is `scope` (in singular), but it is actually a long string with "scopes" separated by spaces.

Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

The webhooks that you define will end up in the **OpenAPI** schema and the automatic **docs UI**.

/// info

The `app.webhooks` object is actually just an `APIRouter`, the same type you would use when structuring your app with multiple files.

///

        }
        msg += ")";
        logger.debug(msg);
    }

    @Override
    public void manageArtifactVersion(Artifact artifact, Artifact replacement) {
        // only show msg if a change is actually taking place
        if (!replacement.getVersion().equals(artifact.getVersion())) {
            String msg = indent + artifact + " (applying version: " + replacement.getVersion() + ")";
            logger.debug(msg);

## Return Type and Data Filtering { #return-type-and-data-filtering }

Let's continue from the previous example. We wanted to **annotate the function with one type**, but we wanted to be able to return from the function something that actually includes **more data**.

We want FastAPI to keep **filtering** the data using the response model. So that even though the function returns more data, the response will only include the fields declared in the response model.

       changes with every test execution, such that running the test
       actually changes the test classpath itself. This means that it
       can"t benefit from incremental build acceleration, because on every
       execution it sees that the classpath has changed, and so to be
       safe, it needs to re-run.

       - This is unfortunate, because actually it would be safe to declare

        assertTrue(rule.isTarget(1, 30, 1)); // 1:30 on Sunday (actually Monday morning)
        assertTrue(rule.isTarget(2, 0, 1)); // 2:00 on Sunday (actually Monday morning)

        // Outside range
        assertFalse(rule.isTarget(21, 59, 1)); // 21:59 on Sunday
        assertFalse(rule.isTarget(2, 1, 1)); // 2:01 on Sunday (actually Monday morning)
    }

    @Test