feat(account): Steam ID and blocked state from Auth (V25)

A blocked user gets no sync and leaves the landing stats. A new or removed Steam ID stops the nightly sync of the old one. No token check in Core: the token lives until it expires.

src/test/java/core_service/modules/account/api/InternalAccountControllerTest.java

@@ -45,6 +45,7 @@ class InternalAccountControllerTest extends AbstractIntegrationTest {
     @AfterEach
     void cleanUp() {
         jdbc.update("delete from deleted_user where user_id in (?, 42)", USER_ID);
+        jdbc.update("delete from blocked_user where user_id in (?, 42)", USER_ID);
     }
 
     private static String serviceToken() {

src/test/java/core_service/modules/account/repo/AccountStateRepositoryTest.java

@@ -0,0 +1,103 @@
+package core_service.modules.account.repo;
+
+import core_service.modules.account.domain.AccountState;
+import core_service.shared.test.AbstractPersistenceTest;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Import;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Import(AccountStateRepository.class)
+class AccountStateRepositoryTest extends AbstractPersistenceTest {
+
+    private static final long OLD_STEAM_ID = 76561198000000001L;
+    private static final long NEW_STEAM_ID = 76561198000000002L;
+
+    @Autowired
+    private AccountStateRepository repository;
+
+    @Autowired
+    private JdbcTemplate jdbc;
+
+    @BeforeEach
+    void seed() {
+        jdbc.update("delete from blocked_user");
+        for (long userId : List.of(1L, 2L)) {
+            jdbc.update("insert into user_steam_sync (user_id, steam_id, last_synced_at, user_seen_at) "
+                    + "values (?, ?, now(), now())", userId, String.valueOf(OLD_STEAM_ID));
+        }
+    }
+
+    private Map<String, Object> sync(long userId) {
+        return jdbc.queryForMap("select steam_id, last_synced_at, user_seen_at from user_steam_sync where user_id = ?",
+                userId);
+    }
+
+    private List<Long> blocked() {
+        return jdbc.queryForList("select user_id from blocked_user order by user_id", Long.class);
+    }
+
+    @Test
+    void block_StopsTheNightlySyncAndUnblockLiftsTheMarker() {
+        repository.apply(new AccountState(1L, OLD_STEAM_ID, true));
+
+        assertThat(blocked()).containsExactly(1L);
+        assertThat(sync(1L).get("user_seen_at")).isNull();
+        assertThat(sync(2L).get("user_seen_at")).isNotNull();
+
+        repository.apply(new AccountState(1L, OLD_STEAM_ID, false));
+
+        assertThat(blocked()).isEmpty();
+    }
+
+    // steam_id stays: the next sync with the new ID compares with it and drops the old account's games.
+    @Test
+    void newSteamId_StopsTheNightlySyncOfTheOldIdAndSyncsOnTheNextVisit() {
+        repository.apply(new AccountState(1L, NEW_STEAM_ID, false));
+
+        assertThat(sync(1L).get("steam_id")).isEqualTo(String.valueOf(OLD_STEAM_ID));
+        assertThat(sync(1L).get("last_synced_at")).isNull();
+        assertThat(sync(1L).get("user_seen_at")).isNull();
+    }
+
+    @Test
+    void sameSteamId_KeepsTheLastSync() {
+        repository.apply(new AccountState(1L, OLD_STEAM_ID, false));
+
+        assertThat(sync(1L).get("last_synced_at")).isNotNull();
+    }
+
+    @Test
+    void noSteamId_StopsTheNightlySync() {
+        repository.apply(new AccountState(1L, null, false));
+
+        assertThat(sync(1L).get("user_seen_at")).isNull();
+        assertThat(sync(1L).get("steam_id")).isEqualTo(String.valueOf(OLD_STEAM_ID));
+    }
+
+    @Test
+    void userWithoutASyncRow_GetsOnlyTheBlock() {
+        repository.apply(new AccountState(3L, NEW_STEAM_ID, true));
+
+        assertThat(blocked()).containsExactly(3L);
+        assertThat(jdbc.queryForList("select user_id from user_steam_sync where user_id = 3", Long.class)).isEmpty();
+    }
+
+    @Test
+    void replaceAll_LiftsTheBlocksAuthNoLongerSends() {
+        repository.apply(new AccountState(1L, OLD_STEAM_ID, true));
+        repository.apply(new AccountState(2L, OLD_STEAM_ID, true));
+
+        repository.replaceAll(List.of(new AccountState(2L, OLD_STEAM_ID, true)));
+        assertThat(blocked()).containsExactly(2L);
+
+        repository.replaceAll(List.of());
+        assertThat(blocked()).isEmpty();
+    }
+}

src/test/java/core_service/modules/library/repo/UserSteamSyncRepositoryTest.java

@@ -45,6 +45,14 @@ class UserSteamSyncRepositoryTest extends AbstractPersistenceTest {
         assertThat(claim(3L)).isZero();
     }
 
+    @Test
+    void tryClaimRun_RefusesABlockedUser() {
+        repository.saveAndFlush(new UserSteamSync(3L, STEAM_ID));
+        jdbc.update("insert into blocked_user (user_id) values (3)");
+
+        assertThat(claim(3L)).isZero();
+    }
+
     @Test
     void tryClaimRun_RunningRowStartedLongAgo_IsClaimedEvenWhenTheLastSyncEndedRecently() {
         jdbc.update("insert into user_steam_sync (user_id, steam_id, last_synced_at, last_sync_status, sync_started_at) " +

src/test/java/core_service/modules/stats/repo/StatsRepositoryTest.java

@@ -76,4 +76,15 @@ class StatsRepositoryTest extends AbstractPersistenceTest {
         hiddenGames_LeaveEveryNumber();
         hiddenGames_LeaveTheTopLists();
     }
+
+    @Test
+    void blockedUsers_LeaveEveryNumberAndTheTopLists() {
+        steamGameRepository.saveAndFlush(new SteamGame(620L, "Portal 2", null, Instant.now()));
+        userGameRepository.saveAllAndFlush(List.of(new UserGame(3L, 620L, 900, Instant.now(), Instant.now()),
+                new UserGame(3L, 220L, 0, Instant.now(), Instant.now())));
+        jdbc.update("INSERT INTO blocked_user (user_id) VALUES (3)");
+
+        hiddenGames_LeaveEveryNumber();
+        hiddenGames_LeaveTheTopLists();
+    }
 }

src/test/resources/contract/auth-core-contract.json

@@ -55,6 +55,16 @@
       "path": "/internal/accounts/deleted",
       "request": {"userIds": []}
     },
+    "applyStates": {
+      "method": "POST",
+      "path": "/internal/accounts/states",
+      "request": {"accounts": [{"userId": 42, "steamId": 76561198000000001, "blocked": true}]}
+    },
+    "replaceStates": {
+      "method": "PUT",
+      "path": "/internal/accounts/states",
+      "request": {"accounts": [{"userId": 42, "steamId": null, "blocked": false}]}
+    },
     "purge": {
       "method": "POST",
       "path": "/internal/accounts/purge",