merge: master → feat/tests, resolve conflicts + fix all tests

- odstraněn .woodpecker/workflow.yaml (CI přesunuto na Gitea Actions)
- tsconfig.json: exclude src/tests/**/* (feat/tests verze)
- jest.config.js: testEnvironment node + master cesty
- auth/pizza/voting tests: union obou větví, použit resetMemoryStorage()
- service.test.ts: jest.useFakeTimers místo MOCK_DATA=true
- všechny testy: 167/167 PASS

server/src/tests/voting.test.ts

@@ -1,62 +1,73 @@
+import { getUserVotes, updateFeatureVote, getVotingStats } from '../voting';
+import { resetMemoryStorage } from '../storage/memory';
 import { FeatureRequest } from '../../../types/gen/types.gen';
 
-const mockStorageData = new Map<string, any>();
-jest.mock('../storage', () => ({
-    __esModule: true,
-    default: () => ({
-        hasData: async (key: string) => mockStorageData.has(key),
-        getData: async <T>(key: string) => mockStorageData.get(key) as T,
-        setData: async <T>(key: string, val: T) => void mockStorageData.set(key, val),
-    }),
-    storageReady: Promise.resolve(),
-}));
+const OPT_A = FeatureRequest.STATISTICS;
+const OPT_B = FeatureRequest.UI;
 
-import { updateFeatureVote, getVotingStats } from '../voting';
-
-beforeEach(() => mockStorageData.clear());
+beforeEach(() => {
+    resetMemoryStorage();
+});
 
 describe('updateFeatureVote', () => {
-    const feat = 'FEATURE_A' as FeatureRequest;
-
     test('přidá hlas pro nového uživatele', async () => {
-        const result = await updateFeatureVote('alice', feat, true);
-        expect(result['alice']).toContain(feat);
+        const result = await updateFeatureVote('alice', OPT_A, true);
+        expect(result['alice']).toContain(OPT_A);
     });
 
     test('vyhodí chybu při duplicitním hlasování', async () => {
-        await updateFeatureVote('alice', feat, true);
-        await expect(updateFeatureVote('alice', feat, true)).rejects.toThrow('hlasovali');
+        await updateFeatureVote('alice', OPT_A, true);
+        await expect(updateFeatureVote('alice', OPT_A, true)).rejects.toThrow('hlasovali');
     });
 
     test('odebere hlas', async () => {
-        await updateFeatureVote('alice', feat, true);
-        await updateFeatureVote('alice', feat, false);
+        await updateFeatureVote('alice', OPT_A, true);
+        await updateFeatureVote('alice', OPT_A, false);
         const stats = await getVotingStats();
-        expect(stats[feat] ?? 0).toBe(0);
+        expect(stats[OPT_A] ?? 0).toBe(0);
     });
 
     test('odebrání neexistujícího hlasu je no-op', async () => {
-        await expect(updateFeatureVote('alice', feat, false)).resolves.not.toThrow();
+        await expect(updateFeatureVote('alice', OPT_A, false)).resolves.not.toThrow();
+    });
+
+    test('odebrání posledního hlasu odstraní login ze storage', async () => {
+        await updateFeatureVote('alice', OPT_A, true);
+        const data = await updateFeatureVote('alice', OPT_A, false);
+        expect('alice' in data).toBe(false);
     });
 
     test('vyhodí chybu po 4 hlasech', async () => {
-        const features = ['FA', 'FB', 'FC', 'FD'] as FeatureRequest[];
-        for (const f of features) {
-            await updateFeatureVote('alice', f, true);
+        const options = Object.values(FeatureRequest);
+        for (let i = 0; i < 4; i++) {
+            await updateFeatureVote('alice', options[i], true);
         }
-        await expect(updateFeatureVote('alice', 'FE' as FeatureRequest, true)).rejects.toThrow('4');
+        await expect(updateFeatureVote('alice', options[4], true)).rejects.toThrow('4');
+    });
+});
+
+describe('getUserVotes', () => {
+    test('vrátí hlasy uživatele', async () => {
+        await updateFeatureVote('alice', OPT_A, true);
+        const votes = await getUserVotes('alice');
+        expect(votes).toContain(OPT_A);
+    });
+
+    test('vrátí prázdné pole pro uživatele bez hlasů', async () => {
+        const votes = await getUserVotes('neexistujici');
+        expect(votes).toEqual([]);
     });
 });
 
 describe('getVotingStats', () => {
     test('vrátí agregované počty hlasů', async () => {
-        await updateFeatureVote('alice', 'FA' as FeatureRequest, true);
-        await updateFeatureVote('bob', 'FA' as FeatureRequest, true);
-        await updateFeatureVote('bob', 'FB' as FeatureRequest, true);
+        await updateFeatureVote('alice', OPT_A, true);
+        await updateFeatureVote('bob', OPT_A, true);
+        await updateFeatureVote('bob', OPT_B, true);
 
         const stats = await getVotingStats();
-        expect(stats['FA']).toBe(2);
-        expect(stats['FB']).toBe(1);
+        expect(stats[OPT_A]).toBe(2);
+        expect(stats[OPT_B]).toBe(1);
     });
 
     test('vrátí prázdný objekt bez hlasů', async () => {