games_app/backend/src/tests/candleGenerationService.test.ts
2026-07-26 01:37:43 +02:00

134 lines
4.7 KiB
TypeScript

import { describe, test } from 'node:test';
import assert from 'node:assert/strict';
import {
resolvePoolOutcome,
resolveAutoNoBetOutcome,
countConsecutiveDirectionalOutcomes,
type PoolNeutralityRules,
} from '../services/candleGenerationService';
const defaultRules: PoolNeutralityRules = {
minTolerancePercent: 2,
maxTolerancePercent: 95,
minToleranceEnabled: true,
maxToleranceEnabled: true,
};
describe('resolvePoolOutcome neutrality rules', () => {
test('declares neutral when pools are within min tolerance (49/51)', () => {
const outcome = resolvePoolOutcome(49, 51, defaultRules, 'minority');
assert.equal(outcome.type, 'neutral');
});
test('declares neutral when pools are exactly 50/50', () => {
const outcome = resolvePoolOutcome(100, 100, defaultRules, 'minority');
assert.equal(outcome.type, 'neutral');
});
test('declares neutral when one side reaches max imbalance (95/5)', () => {
const outcome = resolvePoolOutcome(95, 5, defaultRules, 'minority');
assert.equal(outcome.type, 'neutral');
});
test('declares neutral when one side exceeds max imbalance (98/2)', () => {
const outcome = resolvePoolOutcome(98, 2, defaultRules, 'minority');
assert.equal(outcome.type, 'neutral');
});
test('picks a winner when gap is above min and below max imbalance (70/30)', () => {
const outcome = resolvePoolOutcome(70, 30, defaultRules, 'minority');
assert.equal(outcome.type, 'long_win');
});
test('picks minority winner when pools are balanced enough but not extreme', () => {
const outcome = resolvePoolOutcome(40, 60, defaultRules, 'minority');
assert.equal(outcome.type, 'short_win');
});
test('skips min rule when disabled', () => {
const rules = { ...defaultRules, minToleranceEnabled: false };
const outcome = resolvePoolOutcome(49, 51, rules, 'minority');
assert.equal(outcome.type, 'short_win');
});
test('skips max rule when disabled', () => {
const rules = { ...defaultRules, maxToleranceEnabled: false };
const outcome = resolvePoolOutcome(98, 2, rules, 'minority');
assert.equal(outcome.type, 'long_win');
});
test('solo long pool with max rule on → neutral refund', () => {
const outcome = resolvePoolOutcome(0, 10, defaultRules, 'majority');
assert.equal(outcome.type, 'neutral');
});
test('solo short pool with max rule on → neutral refund', () => {
const outcome = resolvePoolOutcome(10, 0, defaultRules, 'majority');
assert.equal(outcome.type, 'neutral');
});
test('solo long pool with max rule off → majority wins', () => {
const rules = { ...defaultRules, maxToleranceEnabled: false };
const outcome = resolvePoolOutcome(0, 10, rules, 'majority');
assert.equal(outcome.type, 'long_win');
assert.equal(outcome.winner, 'long');
});
test('solo long pool with minority rule and max off → empty short side wins', () => {
const rules = { ...defaultRules, maxToleranceEnabled: false };
const outcome = resolvePoolOutcome(0, 10, rules, 'minority');
assert.equal(outcome.type, 'short_win');
assert.equal(outcome.winner, 'short');
});
test('both sides extreme imbalance still neutral when max rule on', () => {
const outcome = resolvePoolOutcome(95, 5, defaultRules, 'majority');
assert.equal(outcome.type, 'neutral');
});
test('exact equal pools are neutral even when min rule is off', () => {
const rules = { ...defaultRules, minToleranceEnabled: false, maxToleranceEnabled: false };
const outcome = resolvePoolOutcome(50, 50, rules, 'majority');
assert.equal(outcome.type, 'neutral');
});
});
describe('resolveAutoNoBetOutcome consecutive direction cap', () => {
test('counts consecutive directional outcomes from newest', () => {
const { type, count } = countConsecutiveDirectionalOutcomes([
'long_win',
'long_win',
'long_win',
'short_win',
]);
assert.equal(type, 'long_win');
assert.equal(count, 3);
});
test('forces opposite direction after 5 consecutive same outcomes', () => {
const recent = [
'short_win',
'short_win',
'short_win',
'short_win',
'short_win',
] as const;
const outcome = resolveAutoNoBetOutcome([...recent]);
assert.equal(outcome.type, 'long_win');
assert.equal(outcome.winner, 'long');
});
test('does not force flip before 5 consecutive', () => {
const recent = ['long_win', 'long_win', 'long_win', 'long_win'] as const;
let sawLong = false;
let sawShort = false;
for (let i = 0; i < 40; i++) {
const outcome = resolveAutoNoBetOutcome([...recent]);
if (outcome.type === 'long_win') sawLong = true;
if (outcome.type === 'short_win') sawShort = true;
if (sawLong && sawShort) break;
}
assert.equal(sawLong && sawShort, true);
});
});