@arcanahq/cardgames 1.0.0

package/assembly/__tests__/blackjack/actions/insurance.spec.ts

@@ -0,0 +1,39 @@
+// @ts-nocheck
+/**
+ * Tests for insurance offer validation
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import {
+  shouldOfferInsurance
+} from "../../../blackjack/actions";
+import { BlackjackRules } from "../../../blackjack/rules";
+
+// ============================================================================
+// shouldOfferInsurance Tests
+// ============================================================================
+
+describe("shouldOfferInsurance", () => {
+  test("should offer insurance when dealer shows ace and insurance is enabled", () => {
+    const standardRules = BlackjackRules.standard();
+    expect(shouldOfferInsurance("A", standardRules)).equal(true);
+  });
+  
+  test("should not offer insurance when dealer does not show ace", () => {
+    const standardRules = BlackjackRules.standard();
+    expect(shouldOfferInsurance("K", standardRules)).equal(false);
+    expect(shouldOfferInsurance("10", standardRules)).equal(false);
+    expect(shouldOfferInsurance("5", standardRules)).equal(false);
+  });
+  
+  test("should not offer insurance when insurance is disabled", () => {
+    const rules = new BlackjackRules(17, false, 4, false, true, false, false); // insuranceOffered = false
+    expect(shouldOfferInsurance("A", rules)).equal(false);
+  });
+  
+  test("should not offer insurance when dealer shows ace but insurance disabled", () => {
+    const rules = new BlackjackRules(17, false, 4, false, true, false, false); // insuranceOffered = false
+    expect(shouldOfferInsurance("A", rules)).equal(false);
+  });
+});
+

package/assembly/__tests__/blackjack/actions/split.spec.ts

@@ -0,0 +1,96 @@
+// @ts-nocheck
+/**
+ * Tests for split action validation and availability
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import {
+  calculateAvailableActions,
+  validateCanSplit
+} from "../../../blackjack/actions";
+import { BlackjackRules } from "../../../blackjack/rules";
+
+// ============================================================================
+// calculateAvailableActions - Split Tests
+// ============================================================================
+
+describe("calculateAvailableActions - Split", () => {
+  test("should allow split when cards can be split and under max hands", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      false,
+      false,
+      "PLAYING",
+      1, // playerHandsCount
+      true, // canSplit
+      standardRules
+    );
+    expect(actions.canSplit).equal(true);
+  });
+  
+  test("should not allow split when at max hands", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      false,
+      false,
+      "PLAYING",
+      4, // playerHandsCount (at max)
+      true,
+      standardRules
+    );
+    expect(actions.canSplit).equal(false);
+  });
+  
+  test("should not allow split when cards cannot be split", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      false,
+      false,
+      "PLAYING",
+      1,
+      false, // canSplit
+      standardRules
+    );
+    expect(actions.canSplit).equal(false);
+  });
+});
+
+// ============================================================================
+// validateCanSplit Tests
+// ============================================================================
+
+describe("validateCanSplit", () => {
+  test("should not throw when hand can be split", () => {
+    const standardRules = BlackjackRules.standard();
+    validateCanSplit(2, 1, true, standardRules);
+    // If we get here, no error was thrown
+    expect(true).equal(true);
+  });
+  
+  // Note: AssemblyScript doesn't support try-catch, so we test that
+  // the function aborts on invalid input by checking the contract behavior
+  // In a real scenario, invalid split would cause the contract to abort
+  test("should validate split conditions correctly", () => {
+    const standardRules = BlackjackRules.standard();
+    // Valid conditions - should not abort
+    validateCanSplit(2, 1, true, standardRules);
+    expect(true).equal(true);
+  });
+  
+  test("should allow split when under max hands", () => {
+    const standardRules = BlackjackRules.standard();
+    validateCanSplit(2, 3, true, standardRules); // playerHandsCount = 3 (under max)
+    // If we get here, no error was thrown
+    expect(true).equal(true);
+  });
+});
+

package/assembly/__tests__/blackjack/actions/stand.spec.ts

@@ -0,0 +1,103 @@
+// @ts-nocheck
+/**
+ * Tests for stand action validation and availability
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import {
+  calculateAvailableActions,
+  validateCanStand
+} from "../../../blackjack/actions";
+import { BlackjackRules } from "../../../blackjack/rules";
+
+// ============================================================================
+// calculateAvailableActions - Stand Tests
+// ============================================================================
+
+describe("calculateAvailableActions - Stand", () => {
+  test("should allow stand when in playing phase with active hand", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2, // handCardsLength
+      false, // handIsFromSplit
+      false, // handIsSplitAces
+      false, // handIsStanding
+      false, // handIsBusted
+      "PLAYING", // gamePhase
+      1, // playerHandsCount
+      false, // canSplit
+      standardRules
+    );
+    expect(actions.canStand).equal(true);
+  });
+  
+  test("should not allow stand when hand is already standing", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      true, // handIsStanding
+      false,
+      "PLAYING",
+      1,
+      false,
+      standardRules
+    );
+    expect(actions.canStand).equal(false);
+  });
+  
+  test("should not allow stand when hand is busted", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      3,
+      false,
+      false,
+      false,
+      true, // handIsBusted
+      "PLAYING",
+      1,
+      false,
+      standardRules
+    );
+    expect(actions.canStand).equal(false);
+  });
+  
+  test("should not allow stand when not in playing phase", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      false,
+      false,
+      "BETTING", // gamePhase
+      1,
+      false,
+      standardRules
+    );
+    expect(actions.canStand).equal(false);
+  });
+});
+
+// ============================================================================
+// validateCanStand Tests
+// ============================================================================
+
+describe("validateCanStand", () => {
+  test("should not throw when hand can be stood", () => {
+    validateCanStand(false, false);
+    // If we get here, no error was thrown
+    expect(true).equal(true);
+  });
+  
+  // Note: AssemblyScript doesn't support try-catch, so we test that
+  // the function aborts on invalid input by checking the contract behavior
+  // In a real scenario, invalid stand would cause the contract to abort
+  test("should validate stand conditions correctly", () => {
+    // Valid conditions - should not abort
+    validateCanStand(false, false);
+    expect(true).equal(true);
+  });
+});
+

package/assembly/__tests__/blackjack/actions/surrender.spec.ts

@@ -0,0 +1,89 @@
+// @ts-nocheck
+/**
+ * Tests for surrender action validation and availability
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import {
+  calculateAvailableActions,
+  validateCanSurrender
+} from "../../../blackjack/actions";
+import { BlackjackRules } from "../../../blackjack/rules";
+
+// ============================================================================
+// calculateAvailableActions - Surrender Tests
+// ============================================================================
+
+describe("calculateAvailableActions - Surrender", () => {
+  test("should allow surrender on first two cards of original hand", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      false, // handIsFromSplit
+      false,
+      false,
+      false,
+      "PLAYING",
+      1,
+      false,
+      standardRules
+    );
+    expect(actions.canSurrender).equal(true);
+  });
+  
+  test("should not allow surrender on split hand", () => {
+    const standardRules = BlackjackRules.standard();
+    const actions = calculateAvailableActions(
+      2,
+      true, // handIsFromSplit
+      false,
+      false,
+      false,
+      "PLAYING",
+      2,
+      false,
+      standardRules
+    );
+    expect(actions.canSurrender).equal(false);
+  });
+  
+  test("should not allow surrender when surrender not allowed", () => {
+    const rules = new BlackjackRules(17, false, 4, false, false); // surrenderAllowed = false
+    const actions = calculateAvailableActions(
+      2,
+      false,
+      false,
+      false,
+      false,
+      "PLAYING",
+      1,
+      false,
+      rules
+    );
+    expect(actions.canSurrender).equal(false);
+  });
+});
+
+// ============================================================================
+// validateCanSurrender Tests
+// ============================================================================
+
+describe("validateCanSurrender", () => {
+  test("should not throw when hand can be surrendered", () => {
+    const standardRules = BlackjackRules.standard();
+    validateCanSurrender(2, false, standardRules);
+    // If we get here, no error was thrown
+    expect(true).equal(true);
+  });
+  
+  // Note: AssemblyScript doesn't support try-catch, so we test that
+  // the function aborts on invalid input by checking the contract behavior
+  // In a real scenario, invalid surrender would cause the contract to abort
+  test("should validate surrender conditions correctly", () => {
+    const standardRules = BlackjackRules.standard();
+    // Valid conditions - should not abort
+    validateCanSurrender(2, false, standardRules);
+    expect(true).equal(true);
+  });
+});
+

package/assembly/__tests__/blackjack/actions/test.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+/**
+ * Test entry point for blackjack actions
+ * Imports all action test files
+ */
+
+// Import common tests
+import "./common.spec";
+
+// Import action-specific tests
+import "./stand.spec";
+import "./double.spec";
+import "./split.spec";
+import "./surrender.spec";
+import "./insurance.spec";
+import "./dealer_scenarios.spec";
+import "./edge_cases.spec";
+

package/assembly/__tests__/blackjack/rules.spec.ts

@@ -0,0 +1,231 @@
+// @ts-nocheck
+/**
+ * Comprehensive tests for blackjack rules configuration
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { BlackjackRules } from "../../blackjack/rules";
+import { dealerShouldHit, isSoftHand, calculateBlackjackHandValue } from "../../blackjack/blackjack";
+import { Card } from "../../cards";
+
+// ============================================================================
+// BlackjackRules Class Tests
+// ============================================================================
+
+describe("BlackjackRules", () => {
+  test("should create standard rules with correct defaults", () => {
+    const rules = BlackjackRules.standard();
+    expect(rules.dealerStandValue).equal(17);
+    expect(rules.hitOnSoft17).equal(false);
+    expect(rules.maxSplitHands).equal(4);
+    expect(rules.doubleAfterSplit).equal(false);
+    expect(rules.surrenderAllowed).equal(true);
+    expect(rules.insuranceOffered).equal(true);
+    expect(rules.isSpanish21).equal(false);
+    expect(rules.deckSize).equal(52);
+    expect(rules.blackjackValue).equal(21);
+    expect(rules.bustValue).equal(22);
+  });
+  
+  test("should create Spanish 21 rules correctly", () => {
+    const rules = BlackjackRules.spanish21();
+    expect(rules.dealerStandValue).equal(17);
+    expect(rules.hitOnSoft17).equal(true);
+    expect(rules.maxSplitHands).equal(4);
+    expect(rules.doubleAfterSplit).equal(true);
+    expect(rules.surrenderAllowed).equal(true);
+    expect(rules.insuranceOffered).equal(false);
+    expect(rules.isSpanish21).equal(true);
+    expect(rules.deckSize).equal(48);
+  });
+  
+  test("should create rules with dealer hitting on soft 17", () => {
+    const rules = BlackjackRules.dealerHitsSoft17();
+    expect(rules.dealerStandValue).equal(17);
+    expect(rules.hitOnSoft17).equal(true);
+  });
+  
+  test("should create rules allowing double after split", () => {
+    const rules = BlackjackRules.allowDoubleAfterSplit();
+    expect(rules.doubleAfterSplit).equal(true);
+  });
+  
+  test("should allow custom rule configuration", () => {
+    const rules = new BlackjackRules(
+      18, // dealerStandValue
+      true, // hitOnSoft17
+      3, // maxSplitHands
+      true, // doubleAfterSplit
+      false, // surrenderAllowed
+      false, // lateSurrender
+      false, // insuranceOffered
+      false // isSpanish21
+    );
+    expect(rules.dealerStandValue).equal(18);
+    expect(rules.hitOnSoft17).equal(true);
+    expect(rules.maxSplitHands).equal(3);
+    expect(rules.doubleAfterSplit).equal(true);
+    expect(rules.surrenderAllowed).equal(false);
+    expect(rules.insuranceOffered).equal(false);
+  });
+  
+  test("should set deck size to 48 for Spanish 21", () => {
+    const rules = new BlackjackRules(17, false, 4, false, true, false, true, true);
+    expect(rules.isSpanish21).equal(true);
+    expect(rules.deckSize).equal(48);
+  });
+  
+  test("should set deck size to 52 for standard blackjack", () => {
+    const rules = new BlackjackRules(17, false, 4, false, true, false, true, false);
+    expect(rules.isSpanish21).equal(false);
+    expect(rules.deckSize).equal(52);
+  });
+  
+  test("should have correct payout defaults", () => {
+    const rules = BlackjackRules.standard();
+    expect(rules.payoutBlackjack).equal(1.5);
+    expect(rules.payoutWin).equal(1.0);
+    expect(rules.payoutPush).equal(1.0);
+    expect(rules.payoutLose).equal(0.0);
+    expect(rules.payoutSurrender).equal(0.5);
+    expect(rules.payoutInsurance).equal(2.0);
+  });
+  
+  test("should allow custom payouts", () => {
+    const rules = new BlackjackRules(
+      17, false, 4, false, true, false, true, false,
+      2.0, // payoutBlackjack (6:5 instead of 3:2)
+      1.0, // payoutWin
+      1.0, // payoutPush
+      0.0, // payoutLose
+      0.5, // payoutSurrender
+      2.0  // payoutInsurance
+    );
+    expect(rules.payoutBlackjack).equal(2.0);
+  });
+});
+
+// ============================================================================
+// dealerShouldHit Tests (from core)
+// ============================================================================
+
+describe("dealerShouldHit (from core)", () => {
+  test("should hit when below stand value", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "5"));
+    cards.push(new Card("Diamonds", "6"));
+    const rules = BlackjackRules.standard();
+    expect(dealerShouldHit(cards, rules)).equal(true);
+  });
+  
+  test("should not hit when at or above stand value", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "10"));
+    cards.push(new Card("Diamonds", "7"));
+    const rules = BlackjackRules.standard();
+    expect(dealerShouldHit(cards, rules)).equal(false);
+  });
+  
+  test("should hit on soft 17 when hitOnSoft17 is true", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "6"));
+    const rules = BlackjackRules.dealerHitsSoft17();
+    expect(dealerShouldHit(cards, rules)).equal(true);
+  });
+  
+  test("should not hit on soft 17 when hitOnSoft17 is false", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "6"));
+    const rules = BlackjackRules.standard();
+    expect(dealerShouldHit(cards, rules)).equal(false);
+  });
+});
+
+// ============================================================================
+// isSoftHand Tests (from core)
+// ============================================================================
+
+describe("isSoftHand (from core)", () => {
+  test("should identify soft hand with ace", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "6"));
+    expect(isSoftHand(cards)).equal(true);
+  });
+  
+  test("should identify hard hand without ace", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "10"));
+    cards.push(new Card("Diamonds", "7"));
+    expect(isSoftHand(cards)).equal(false);
+  });
+  
+  test("should identify hard hand with ace used as 1", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "10"));
+    cards.push(new Card("Clubs", "10"));
+    expect(isSoftHand(cards)).equal(false);
+  });
+  
+  test("should identify soft hand with multiple aces", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "A"));
+    cards.push(new Card("Clubs", "5"));
+    expect(isSoftHand(cards)).equal(true);
+  });
+});
+
+// ============================================================================
+// calculateBlackjackHandValue Tests (from core)
+// ============================================================================
+
+describe("calculateBlackjackHandValue (from core)", () => {
+  test("should calculate value for number cards", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "5"));
+    cards.push(new Card("Diamonds", "7"));
+    expect(calculateBlackjackHandValue(cards)).equal(12);
+  });
+  
+  test("should calculate value for face cards", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "K"));
+    cards.push(new Card("Diamonds", "Q"));
+    expect(calculateBlackjackHandValue(cards)).equal(20);
+  });
+  
+  test("should calculate value with ace as 11", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "6"));
+    expect(calculateBlackjackHandValue(cards)).equal(17);
+  });
+  
+  test("should calculate value with ace as 1 when needed", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "10"));
+    cards.push(new Card("Clubs", "10"));
+    expect(calculateBlackjackHandValue(cards)).equal(21);
+  });
+  
+  test("should calculate blackjack correctly", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "K"));
+    expect(calculateBlackjackHandValue(cards)).equal(21);
+  });
+  
+  test("should handle multiple aces correctly", () => {
+    const cards: Card[] = [];
+    cards.push(new Card("Hearts", "A"));
+    cards.push(new Card("Diamonds", "A"));
+    cards.push(new Card("Clubs", "5"));
+    expect(calculateBlackjackHandValue(cards)).equal(17);
+  });
+});
+