134 lines
4.7 KiB
TypeScript
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);
|
|
});
|
|
});
|