Activation activation = profile.getActivation();
        return activation != null && activation.getOs() != null;
    }

    @Override
    public boolean isActive(Profile profile) {
        Activation activation = profile.getActivation();
        ActivationOS os = activation.getOs();

        boolean result = ensureAtLeastOneNonNull(os);

        assertEquals(NbtAddress.B_NODE, nbtAddress.getNodeType(mockContext));
        assertTrue(nbtAddress.isBeingDeleted(mockContext));
        assertTrue(nbtAddress.isInConflict(mockContext));
        assertFalse(nbtAddress.isActive(mockContext));
        assertTrue(nbtAddress.isPermanent(mockContext));
        assertArrayEquals(testMacAddress, nbtAddress.getMacAddress(mockContext));
    }

    @Test
    void testUnwrap() {

    )
    response = client.get(
        "/users/me", headers={"Authorization": f"Bearer {access_token}"}
    )
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "Inactive user"}


def test_read_items(mod: ModuleType):
    client = TestClient(mod.app)
    access_token = get_access_token(scope="me items", client=client)
    response = client.get(

E para comunicar usando WebSockets com seu backend, você provavelmente usaria as utilidades do seu frontend.

Ou você pode ter um aplicativo móvel nativo que se comunica diretamente com seu backend WebSocket, em código nativo.

Ou você pode ter qualquer outra forma de comunicar com o endpoint WebSocket.

---

@Named("os")
@Singleton
@Deprecated(since = "4.0.0")
public class OperatingSystemProfileActivator implements ProfileActivator {

    private static final String REGEX_PREFIX = "regex:";

    @Override
    public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        Activation activation = profile.getActivation();

        if (activation == null) {
            return false;
        }

    }

    protected void assertActivation(boolean active, Profile profile, ProfileActivationContext context) {
        SimpleProblemCollector problems = new SimpleProblemCollector();

        assertEquals(active, activator.isActive(new org.apache.maven.model.Profile(profile), context, problems));

        assertEquals(0, problems.getErrors().size(), problems.getErrors().toString());

        if (activeProxy == null) {
            java.util.List<Proxy> proxies = getProxies();
            if (proxies != null && !proxies.isEmpty()) {
                for (Proxy proxy : proxies) {
                    if (proxy.isActive()) {
                        activeProxy = proxy;
                        break;
                    }
                }
            }
        }
        return activeProxy;
    }

 */
@Named("packaging")
@Singleton
@Deprecated(since = "4.0.0")
public class PackagingProfileActivator implements ProfileActivator {

    @Override
    public boolean isActive(
            org.apache.maven.model.Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        return getActivationPackaging(profile).map(p -> isPackaging(context, p)).orElse(false);
    }

}
```

### 비활성된 유저

이제 비활성된 사용자로 시도하고, 인증해봅시다:

유저명: `alice`

패스워드: `secret2`

그리고 `/users/me` 경로와 함께 `GET` 작업을 사용해 봅시다.

다음과 같은 "Inactive user" 오류가 발생합니다:

```JSON
{
  "detail": "Inactive user"
}
```

## 요약

이제 API에 대한 `username` 및 `password`를 기반으로 완전한 보안 시스템을 구현할 수 있는 도구가 있습니다.

이러한 도구를 사용하여 보안 시스템을 모든 데이터베이스 및 모든 사용자 또는 데이터 모델과 호환되도록 만들 수 있습니다.

        response = client.get(
            "/users/me", headers={"Authorization": f"Bearer {access_token}"}
        )
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "Inactive user"}


def test_read_items(mod: ModuleType):
    client = TestClient(mod.app)
    access_token = get_access_token(client=client)
    response = client.get(