⚫️ 🚫 🤔. **FastAPI** 🔜 💭 ⚫️❔.

/// note

🚥 👆 🚫 💭, ✅ [🔁: *"🏃 ❓" *](../../async.md){.internal-link target=_blank} 📄 🔃 `async` & `await` 🩺.

///

## 🛠️ ⏮️ 🗄

🌐 📨 📄, 🔬 & 📄 👆 🔗 (& 🎧-🔗) 🔜 🛠️ 🎏 🗄 🔗.

, 🎓 🩺 🔜 ✔️ 🌐 ℹ ⚪️➡️ 👫 🔗 💁‍♂️:

<img src="/img/tutorial/dependencies/image01.png">

## 🙅 ⚙️

{* ../../docs_src/app_testing/tutorial001.py hl[2,12,15:18] *}

/// tip | Consejo

Nota que las funciones de prueba son `def` normales, no `async def`.

Y las llamadas al cliente también son llamadas normales, sin usar `await`.

Esto te permite usar `pytest` directamente sin complicaciones.

///

/// note | Nota Técnica

También podrías usar `from starlette.testclient import TestClient`.

			targetFailed = true
		} else if tgtSize != tgtCtnt.Size {
			fmt.Printf("unreadable on target - size differs upon read: %s\n", tgtCtnt.Key)
			targetFailed = true
		}
	}()
	wg.Wait()

	sobj.Close()
	tobj.Close()

	if !sourceFailed && !targetFailed {
		ssum := srcSha256.Sum(nil)
		tsum := tgtSha256.Sum(nil)
		allgood = bytes.Equal(ssum, tsum)
		if !allgood {

						sm.peerResyncMap[dID] = rs
						wg.Add(1)
						go func() {
							defer wg.Done()
							saveSiteResyncMetadata(ctx, st, newObjectLayerFn())
						}()
					}
				}
				wg.Wait()
				sm.Unlock()
			}
			sTimer.Reset(siteResyncSaveInterval)
		case <-ctx.Done():
			return
		}
	}
}

// update overall site resync state

                    this.handle = this.pipe.openUnshared(this.uncPath, 0, this.access, this.sharing, SmbConstants.ATTR_NORMAL, 0);
                    return this.handle.acquire();
                }

                // Wait for named pipe availability - called when pipe is not immediately available
                if (this.uncPath.startsWith("\\pipe\\")) {

				return fmt.Errorf("unable to load the user `%s`: %w", userName, err)
			}
			userIdentities[index] = user
			return nil
		}, index)
	}

	err := errors.Join(g.Wait()...)
	return userIdentities, err
}

func (iamOS *IAMObjectStore) loadUser(ctx context.Context, user string, userType IAMUserType, m map[string]UserIdentity) error {
	u, err := iamOS.loadUserIdentity(ctx, user, userType)

- The `wait.Poll*` and `wait.ExponentialBackoff*` functions have been deprecated and will be removed in a future release.  Callers should switch to using `wait.PollUntilContextCancel`, `wait.PollUntilContextTimeout`, or `wait.ExponentialBackoffWithContext` as appropriate.
  

        indexUpdater.start();

        // Let it run briefly
        ThreadUtil.sleep(100);

        // Stop the indexer
        indexUpdater.setFinishCrawling(true);

        // Wait for completion with longer timeout
        indexUpdater.join(3000);

        assertFalse(errorOccurred.get());
        // Thread may still be alive in test environment, just check no errors

 *       next task will wait for any running callable (or pending {@code Future} returned by an
 *       {@code AsyncCallable}) to complete, without interrupting it (and without calling {@code
 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.

It doesn't matter. **FastAPI** will know what to do.

/// note

If you don't know, check the [Async: *"In a hurry?"*](../../async.md#in-a-hurry){.internal-link target=_blank} section about `async` and `await` in the docs.

///

## Integrated with OpenAPI { #integrated-with-openapi }