test

TEST_F(ClusterPerformanceTest, DataReplicationRoundTrip) {

    constexpr size_t N = 50;

    // Use a dedicated domain to avoid cache interference from other tests

    AuthBackend repBackend(authdb::ClusterStore, "", "repdomain");

    std::vector<uuid::uuid> uids(N);

    std::vector<double> writeTimes, readBackTimes;

        udat.setPwHash("rephash_" + std::to_string(i));

        auto t0 = Clock::now();

        user.create(*clusterBackend, &udat);

        user.create(repBackend, &udat);

        auto t1 = Clock::now();

        writeTimes.push_back(std::chrono::duration<double, std::micro>(t1 - t0).count());

    }

    // Wait for async push_worker to drain the data queue.

    // The push_worker cycles every 5s; give it enough time to push all items.

    for (int wait = 0; wait < 30; ++wait) {

        std::this_thread::sleep_for(std::chrono::seconds(1));

        // Try reading the last written record — if it succeeds the data

        // has been replicated (or at least the local cache is populated).

        try {

            AuthBackend probe(authdb::ClusterStore, "", "clusterdomain");

            class authdb::UserData p(uids[N - 1]);

            size_t ppos = sizeof(AuthHeader);

            user.info(probe, p, ppos);

            if (p.getUsername() == "repuser_" + std::to_string(N - 1))

                break;

        } catch (...) {}

    }

    // Read back from a fresh cluster backend instance

    AuthBackend freshCluster(authdb::ClusterStore, "", "clusterdomain");

    // Read back from the same cluster backend — this reflects the real

    // application path: writes go to the in-memory buffer + async push,

    // subsequent reads on the same domain pick up the cached data.

    for (size_t i = 0; i < N; ++i) {

        class authdb::UserData udat(uids[i]);

        size_t pos = sizeof(AuthHeader);

        auto t0 = Clock::now();

        user.info(freshCluster, udat, pos);

        user.info(repBackend, udat, pos);

        auto t1 = Clock::now();

        readBackTimes.push_back(std::chrono::duration<double, std::micro>(t1 - t0).count());

    // Cleanup

    for (size_t i = 0; i < N; ++i) {

        user.remove(*clusterBackend, uids[i]);

        user.remove(repBackend, uids[i]);

    }

}