// Second execution
        String result2 = aggregateLogJob.execute();
        assertNotNull(result2);
        assertTrue(result2.contains("Error 2"));

        // Results should be independent
        assertFalse(result1.equals(result2));
    }

    public void test_execute_withEmptyStringException() {
        // Setup mock SearchLogHelper that throws exception with empty message

O "fluxo" da `senha` é um dos caminhos ("fluxos") definidos no OAuth2, para lidar com a segurança e autenticação.

OAuth2 foi projetado para que o backend ou a API pudesse ser independente do servidor que autentica o usuário.

Mas nesse caso, a mesma aplicação **FastAPI** irá lidar com a API e a autenticação.

Então, vamos rever de um ponto de vista simplificado:

        // Execute on both instances
        dataStore1.store(config, callback, params);
        dataStore2.store(config, callback, params);
        dataStore2.store(config, callback, params);

        // Verify independent operation
        assertEquals(1, store1CallCount.get());
        assertEquals(2, store2CallCount.get());
    }

    // Test implementation of IndexUpdateCallback for testing purposes

        assertNull(pc.getPassword());
        verify(spyAuth, times(1)).getPasswordAsCharArray();
    }

    @Test
    @DisplayName("clone: copies fields and cached subject; instances are independent")
    void testCloneCopiesFieldsAndIndependence() throws Exception {
        // Use configuration-based constructor to also exercise copying of configuration/service fields

            assertEquals(type, iate.getType());
            assertEquals(message, e.getMessage());
        }
    }

    public void test_multipleExceptionInstances() {
        // Test multiple instances are independent
        InvalidAccessTokenException exception1 = new InvalidAccessTokenException("Type1", "Message1");
        InvalidAccessTokenException exception2 = new InvalidAccessTokenException("Type2", "Message2");

        SmbNegotiation anotherNegotiation =
                new SmbNegotiation(anotherRequest, anotherResponse, anotherRequestBuffer, anotherResponseBuffer);

        // Verify the instances are independent
        assertNotSame(negotiation.getRequest(), anotherNegotiation.getRequest());
        assertNotSame(negotiation.getResponse(), anotherNegotiation.getResponse());

That's what we'll solve, let's load the model before the requests are handled, but only right before the application starts receiving requests, not while  the code is being loaded.

## Lifespan { #lifespan }

        // Document list size should remain the same
        assertEquals(1, result.getDocumentList().size());
    }

    public void test_multipleBuilds() {
        // Test that each builder creates independent results
        // Create first result with one document
        SearchResult.SearchResultBuilder builder1 = SearchResult.create();
        Map<String, Object> doc1 = new HashMap<>();
        doc1.put("id", "1");

        // Create a copy
        DataStoreParams copy = dataStoreParams.newInstance();

        // Modify original
        dataStoreParams.put("key5", "value5");

        // Verify copy is independent
        assertTrue(dataStoreParams.containsKey("key5"));
        assertFalse(copy.containsKey("key5"));

        // Get as map and verify
        Map<String, Object> map = dataStoreParams.asMap();

Now let's go back a bit and understand what is all that.

The `password` "flow" is one of the ways ("flows") defined in OAuth2, to handle security and authentication.

OAuth2 was designed so that the backend or API could be independent of the server that authenticates the user.

But in this case, the same **FastAPI** application will handle the API and the authentication.

So, let's review it from that simplified point of view: