adds tests

Author: ankushdharkar

.github/workflows/classroom.yml

@@ -13,30 +13,46 @@ jobs:
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
-    - name: Install packages
+    - name: Install pnpm
       run: npm install -g pnpm
-    - name: Test - 2 points
+    - name: Install dependencies
+      run: pnpm i
+    - name: Run Test - 2 points
       id: test-2-points
       uses: classroom-resources/autograding-command-grader@v1
       with:
         test-name: Test - 2 points
-        setup-command: pnpm i
-        command: pnpm test-run-first
+        command: pnpm test-run-basic
         timeout: 1
         max-score: 2
-    - name: Test - 7 points
+    - name: Run Test - 7 points
       id: test-7-points
       uses: classroom-resources/autograding-command-grader@v1
       with:
         test-name: Test - 7 points
-        setup-command: pnpm i
-        command: pnpm test-run-second
+        command: pnpm test-run-real
         timeout: 1
         max-score: 7
+    - name: Check TESTS_FOLDER
+      env:
+        TESTS_FOLDER: ${{ secrets.TESTS_FOLDER }}
+      if: ${{ env.TESTS_FOLDER != '' }}
+      run: echo "TESTS_FOLDER is set ${{ env.TESTS_FOLDER }}"
+    - name: Run Test - Final 24 points
+      id: test-24-points
+      uses: classroom-resources/autograding-command-grader@v1
+      env:
+        TESTS_FOLDER: "${{ secrets.TESTS_FOLDER }}"
+      with:
+        test-name: Test - 24 points
+        command: TESTS_FOLDER=${{ secrets.TESTS_FOLDER }} pnpm test-run-final
+        timeout: 1
+        max-score: 24
     - name: Autograding Reporter
       uses: classroom-resources/autograding-grading-reporter@v1
       env:
-        TEST-2-POINTS_RESULTS: "${{steps.test-2-points.outputs.result}}"
-        TEST-7-POINTS_RESULTS: "${{steps.test-7-points.outputs.result}}"
+        TEST-2-POINTS_RESULTS: "${{ steps.test-2-points.outputs.result }}"
+        TEST-7-POINTS_RESULTS: "${{ steps.test-7-points.outputs.result }}"
+        TEST-24-POINTS_RESULTS: "${{ steps.test-24-points.outputs.result }}"
       with:
-        runners: test-2-points,test-7-points
+        runners: test-2-points,test-7-points,test-24-points

.github/workflows/use-pnpm.yml

@@ -16,4 +16,4 @@ jobs:
     - name: Install dependencies
       run: pnpm install --frozen-lockfile
     - name: Run tests
-      run: pnpm test-run-first
+      run: pnpm test-run-basic

src/__tests__/helpers/TestFactory.ts

@@ -0,0 +1,52 @@
+import User from '@/models/user';
+import Bank from '@/models/bank';
+import { BankAccountId, UserId } from '@/types/Common';
+import GlobalRegistry from '@/services/GlobalRegistry';
+
+export interface TestFixtures {
+  alice: User;
+  aliceUserId: UserId;
+  bob: User;
+  bobUserId: UserId;
+  bank: Bank;
+  bankAllowsNegative: Bank;
+  aliceAccountId: BankAccountId;
+  aliceAccountAllowsNegativeId: BankAccountId;
+  bobAccountId: BankAccountId;
+}
+
+export class TestFactory {
+  static createFixtures(): TestFixtures {
+    GlobalRegistry.clear();
+
+    const bank = Bank.create();
+    const bankAllowsNegative = Bank.create({ isNegativeAllowed: true });
+
+    const aliceAccount = bank.createAccount(1000);
+    const aliceAccountAllowsNegative = bankAllowsNegative.createAccount(200);
+    const bobAccount = bank.createAccount(500);
+
+    const alice = User.create('Alice', [aliceAccount.getId(), aliceAccountAllowsNegative.getId()]);
+    const bob = User.create('Bob', [bobAccount.getId()]);
+
+    return {
+      alice,
+      aliceUserId: alice.getId(),
+      bob,
+      bobUserId: bob.getId(),
+      bank,
+      bankAllowsNegative,
+      aliceAccountId: aliceAccount.getId(),
+      aliceAccountAllowsNegativeId: aliceAccountAllowsNegative.getId(),
+      bobAccountId: bobAccount.getId()
+    };
+  }
+
+  static createBank(options?: { isNegativeAllowed?: boolean }): Bank {
+    return Bank.create(options);
+  }
+
+  static createUser(name: string, accountIds: BankAccountId[]): User {
+    return User.create(name, accountIds);
+  }
+} 

src/__tests__/real.test.ts

@@ -1,12 +1,53 @@
-import { describe, it, expect } from 'vitest';
-import isEqualChecker from '@/index';
+import { describe, beforeEach, it, expect } from 'vitest';
+import { TestFactory } from './helpers/TestFactory';
+import type { TestFixtures } from './helpers/TestFactory';
 
-describe('verify answers', () => {
-  it('should equate same objects', () => {
-    expect(isEqualChecker({ b: 2, a: 1 }, { a: 1, b: 2 })).toBe(true);
+describe('Bank Transfer Tests', () => {
+  let fixtures: TestFixtures;
+
+  beforeEach(() => {
+    fixtures = TestFactory.createFixtures();
+  });
+
+  it('should allow transfer between accounts', () => {
+    const { bank, aliceUserId, bobUserId, aliceAccountId, bobAccountId } = fixtures;
+
+    // Initial balances
+    const aliceAccount = bank.getAccount(aliceAccountId);
+    const bobAccount = bank.getAccount(bobAccountId);
+    expect(aliceAccount.getBalance()).toBe(1000);
+    expect(bobAccount.getBalance()).toBe(500);
+
+    // Perform transfer
+    bank.send(aliceUserId, bobUserId, 300);
+
+    // Check final balances
+    expect(aliceAccount.getBalance()).toBe(700);
+    expect(bobAccount.getBalance()).toBe(800);
+  });
+
+
+  it('should not allow transfer with insufficient funds', () => {
+    const { bank, aliceUserId, bobUserId } = fixtures;
+
+    expect(() => {
+      bank.send(aliceUserId, bobUserId, 2000);
+    }).toThrow('Insufficient funds');
   });
 
-  it('should not equate different  objects', () => {
-    expect(isEqualChecker({ a: 1, c: 2 }, { a: 1, b: 2 })).toBe(false);
+  it('should allow transfer with negative balance', () => {
+    const { bank, bankAllowsNegative, aliceUserId, bobUserId, aliceAccountAllowsNegativeId, bobAccountId } = fixtures;
+
+    const aliceAccountAllowsNegative = bankAllowsNegative.getAccount(aliceAccountAllowsNegativeId);
+    const bobBankId = bank.getId();
+    const bobAccount = bank.getAccount(bobAccountId);
+
+    expect(aliceAccountAllowsNegative.getBalance()).toBe(200);
+    expect(bobAccount.getBalance()).toBe(500);
+
+    bankAllowsNegative.send(aliceUserId, bobUserId, 500, bobBankId);
+
+    expect(aliceAccountAllowsNegative.getBalance()).toBe(-300);
+    expect(bobAccount.getBalance()).toBe(1000);
   });
 });

src/__tests__/simple.test.ts

@@ -1,8 +1,57 @@
 import { describe, it, expect } from 'vitest';
-import isEqual from '@/is-equal';
+import User from '@/models/user';
+import Bank from '@/models/bank';
+import BankAccount from '@/models/bank-account';
+import TransactionService from '@/services/TransactionService';
 
-describe('existence of function', () => {
-  it('should exist', () => {
-    expect(isEqual).toBeDefined();
+
+describe('Banks', () => {
+  it('has a bank class', () => {
+    expect(Bank).toBeDefined();
+  });
+
+  it('can create a bank', () => {
+    const bank = Bank.create();
+    expect(bank.getId()).toBeDefined();
+  });
+
+  it('can create a bank account', () => {
+    const bank = Bank.create();
+    const bankAccount = bank.createAccount(100);
+    expect(bankAccount.getId()).toBeDefined();
+  });
+});
+
+
+describe('Users', () => {
+  it('has a user class', () => {
+    expect(User).toBeDefined();
+  });
+
+  it('can create a user', () => {
+    const user = User.create('Firstname Lastname', []);
+    expect(user).toBeDefined();
+  });
+
+  it('can create a user with accounts', () => {
+    const bank = Bank.create();
+    const bankAccount1Id = bank.createAccount(100).getId();
+    const bankAccount2Id = bank.createAccount(200).getId();
+    const bankAccount3Id = bank.createAccount(300).getId();
+
+    const user = User.create('Firstname Lastname', [bankAccount1Id, bankAccount2Id, bankAccount3Id]);
+    expect(user).toBeDefined();
+  });
+});
+
+describe('Accounts', () => {
+  it('has an account class', () => {
+    expect(BankAccount).toBeDefined();
+  });
+});
+
+describe('Transactions', () => {
+  it('has a transaction service', () => {
+    expect(TransactionService).toBeDefined();
   });
 });