games_app/backend/src/tests/shareCardService.test.ts
2026-09-24 19:09:26 +02:00

235 lines
6.9 KiB
TypeScript

import { describe, test } from 'node:test';
import assert from 'node:assert/strict';
import {
canSharePredictionResult,
canShareWalletOperation,
computeResultAmount,
createShareVerifyToken,
hasConfirmedRealDeposit,
parseShareVerifyToken,
} from '../services/shareCardService';
import type { ShareCardSettingsRow } from '../repositories/shareCardRepository';
function settings(partial: Partial<ShareCardSettingsRow> = {}): ShareCardSettingsRow {
return {
id: 1,
enabled: true,
allow_main_wallet: true,
allow_bonus_wallet: true,
allow_test_wallet: false,
allow_won: true,
allow_lost: true,
allow_refunded: true,
wallet_ops_enabled: true,
allow_deposit: true,
allow_withdrawal: true,
allow_transfer: true,
test_wallet_share_requires_real_deposit: true,
updated_at: new Date(),
...partial,
};
}
describe('share card eligibility', () => {
test('blocks when globally disabled', () => {
assert.equal(
canSharePredictionResult(settings({ enabled: false }), {
stakeAccountKind: 'main',
status: 'won',
}),
false
);
});
test('blocks test wallet when disallowed', () => {
assert.equal(
canSharePredictionResult(settings(), { stakeAccountKind: 'test', status: 'won' }),
false
);
});
test('blocks lost when allow_lost is false', () => {
assert.equal(
canSharePredictionResult(settings({ allow_lost: false }), {
stakeAccountKind: 'main',
status: 'lost',
}),
false
);
});
test('allows main wallet won by default', () => {
assert.equal(
canSharePredictionResult(settings(), { stakeAccountKind: 'main', status: 'won' }),
true
);
});
test('blocks pending bets', () => {
assert.equal(
canSharePredictionResult(settings(), { stakeAccountKind: 'main', status: 'pending' }),
false
);
});
test('blocks test wallet when real deposit is required and user has none', () => {
assert.equal(
canSharePredictionResult(settings({ allow_test_wallet: true }), {
stakeAccountKind: 'test',
status: 'won',
testWalletShareRequiresRealDeposit: true,
hasDeposited: false,
}),
false
);
});
test('allows test wallet when real deposit is required and user has deposited', () => {
assert.equal(
canSharePredictionResult(settings({ allow_test_wallet: true }), {
stakeAccountKind: 'test',
status: 'won',
testWalletShareRequiresRealDeposit: true,
hasDeposited: true,
}),
true
);
});
test('public verify of a test-wallet card does not re-check the owner deposit gate', () => {
assert.equal(
canSharePredictionResult(settings({ allow_test_wallet: true }), {
stakeAccountKind: 'test',
status: 'won',
}),
true
);
});
test('allows test wallet without a deposit when the restriction is disabled', () => {
assert.equal(
canSharePredictionResult(
settings({
allow_test_wallet: true,
test_wallet_share_requires_real_deposit: false,
}),
{
stakeAccountKind: 'test',
status: 'won',
testWalletShareRequiresRealDeposit: false,
hasDeposited: false,
}
),
true
);
});
test('wallet ops respect global and per-type flags', () => {
assert.equal(canShareWalletOperation(settings(), { type: 'deposit' }), true);
assert.equal(canShareWalletOperation(settings(), { type: 'bonus' }), true);
assert.equal(canShareWalletOperation(settings(), { type: 'admin_adjustment' }), true);
assert.equal(
canShareWalletOperation(settings({ wallet_ops_enabled: false }), { type: 'deposit' }),
false
);
assert.equal(
canShareWalletOperation(settings({ allow_deposit: false }), { type: 'bonus' }),
false
);
assert.equal(
canShareWalletOperation(settings({ allow_transfer: false }), { type: 'transfer' }),
false
);
assert.equal(canShareWalletOperation(settings(), { type: 'game_stake' }), false);
});
});
describe('confirmed real-funds deposit (ledger history, not balance)', () => {
test('user with no real deposit is not qualified', () => {
assert.equal(hasConfirmedRealDeposit([]), false);
});
test('user with one confirmed real deposit is qualified', () => {
assert.equal(
hasConfirmedRealDeposit([{ type: 'deposit', status: 'completed' }]),
true
);
});
test('user with several confirmed real deposits is qualified', () => {
assert.equal(
hasConfirmedRealDeposit([
{ type: 'deposit', status: 'completed' },
{ type: 'deposit', status: 'completed' },
{ type: 'withdrawal', status: 'completed' },
]),
true
);
});
test('spent or withdrawn funds do not revoke a confirmed deposit', () => {
assert.equal(
hasConfirmedRealDeposit([
{ type: 'deposit', status: 'completed' },
{ type: 'game_stake', status: 'completed' },
{ type: 'withdrawal', status: 'completed' },
]),
true
);
});
test('test-wallet credits and pending deposits do not qualify', () => {
assert.equal(
hasConfirmedRealDeposit([
{ type: 'test_credit', status: 'completed' },
{ type: 'bonus', status: 'completed' },
{ type: 'admin_adjustment', status: 'completed' },
{ type: 'deposit', status: 'pending' },
{ type: 'deposit', status: 'failed' },
]),
false
);
});
});
describe('share card result amount', () => {
test('won uses full payout including stake', () => {
// stake 5 USDT, payout 9.5 USDT → +9.5 (not net +4.5)
const result = computeResultAmount('won', 5_000_000n, 9_500_000n);
assert.equal(result.resultSignedDisplay, '+9.5');
});
test('lost uses minus stake', () => {
const result = computeResultAmount('lost', 5_000_000n, 0n);
assert.equal(result.resultSignedDisplay, '-5');
});
});
describe('share card verify token', () => {
test('round-trips bet and user ids', () => {
const betId = '11111111-1111-1111-1111-111111111111';
const userId = '22222222-2222-2222-2222-222222222222';
const token = createShareVerifyToken('bet', betId, userId);
const parsed = parseShareVerifyToken(token);
assert.deepEqual(parsed, { kind: 'bet', id: betId, userId });
});
test('round-trips wallet transaction tokens', () => {
const txId = '33333333-3333-3333-3333-333333333333';
const userId = '22222222-2222-2222-2222-222222222222';
const token = createShareVerifyToken('tx', txId, userId);
const parsed = parseShareVerifyToken(token);
assert.deepEqual(parsed, { kind: 'tx', id: txId, userId });
});
test('rejects tampered token', () => {
const token = createShareVerifyToken(
'bet',
'11111111-1111-1111-1111-111111111111',
'22222222-2222-2222-2222-222222222222'
);
assert.equal(parseShareVerifyToken(token + 'x'), null);
assert.equal(parseShareVerifyToken('not-a-token'), null);
});
});