add unit tests + mock service

index.ts

@@ -4,10 +4,12 @@ import fs from "fs";
 import { TezosToolkit } from '@taquito/taquito';
 import { InMemorySigner } from '@taquito/signer';
 import { askQuestion } from './src/utils/askQuestion.js';
-import { getBalance } from './src/services/getBalance.js';
+import { getBalance } from './src/services/balance.service.js';
 import { getAsciiArtText } from './src/utils/getAsciiArtText.js';
+import { createFAToken } from './src/services/token.service.js';
+import { Role } from './src/types/Role.js';
 
-const tezos = new TezosToolkit('https://ghostnet.tezos.marigold.dev');
+const tezos = new TezosToolkit('https://ghostnet.ecadinfra.com');
 const program = new Command();
 
 program
@@ -32,13 +34,13 @@ program
     console.log(`\n`);
 
     // Définir un moyen de connaître le rôle 
-    let ROLE;
-    ROLE = "ADMIN";
-    console.log(chalk.bgBlue(`Vous êtes connecté en tant que ${ROLE}\n`))
+    let role: Role;
+    role = "ADMIN";
+    console.log(chalk.bgBlue(`Vous êtes connecté en tant que ${role}\n`))
 
     while (true) {
       // IF ADMIN
-      if(ROLE === "ADMIN") {
+      if(role === "ADMIN") {
         const choice = await askQuestion(`${chalk.yellow('Que souhaitez-vous faire ?')} \n\n1: Créer une association\n2: Créer un token\n3: Voir mon portefeuille\n0: Quitter\n`);
 
         if (choice === '0') {
@@ -53,6 +55,11 @@ program
             description: description
           };
 
+          console.log("Création du token en cours...")
+          const op = await createFAToken(tezos);
+
+          console.log(op.hash);
+  
           console.log(chalk.green("\nVotre association a été crée !!\n"));
           // Faire l'appel a create association
         } else if (choice === '2') {
@@ -68,7 +75,7 @@ program
       }
       
       // IF ADHERENT
-      if(ROLE === "ADHERENT") {
+      if(role === "ADHERENT" as Role) {
         const choice = await askQuestion(`${chalk.yellow('Que souhaitez-vous faire ?')} \n\n1: Faire une proposition\n2: Voir mon portefeuille\n0: Quitter\n`);
 
         if (choice === '0') {
@@ -87,7 +94,7 @@ program
       }
 
       // IF CONNECTED
-      if(ROLE === "CONNECTED") {
+      if(role === "CONNECTED" as Role) {
         const choice = await askQuestion(`${chalk.yellow('Que souhaitez-vous faire ?')} \n\n1: Rejoindre une association\n2: Voir mon portefeuille\n0: Quitter\n`);
 
         if (choice === '0') {

package.json

@@ -5,7 +5,8 @@
   "description": "Node.js application for command line interface of myasso application",
   "main": "index.ts",
   "scripts": {
-    "start": "ts-node-esm index.ts"
+    "start": "ts-node-esm index.ts",
+    "test": "vitest"
   },
   "author": "M2 Miage",
   "license": "MIT",
@@ -23,6 +24,7 @@
   "devDependencies": {
     "@types/commander": "^2.12.2",
     "@types/figlet": "^1.5.8",
-    "@types/node": "^20.11.19"
+    "@types/node": "^20.11.19",
+    "vitest": "^1.4.0"
   }
 }

src/getRole.ts

+import { TezosToolkit } from "@taquito/taquito";
+
+export function getRole(tezos: TezosToolkit) {
+    // IF HAS TOKEN && HAS ASSOCIATION -> ADMIN
+
+    // IF HAS TOKEN -> ADHERENT
+
+    // ELSE -> CONNECTED
+}
\ No newline at end of file

src/services/association.service.ts

+import { Operation, TezosToolkit } from '@taquito/taquito';
+import { Association } from '../types/Association';
+
+// NEED UPDATE ADDRESS !!
+const address = "KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu"
+
+// NEED UPDATE ENTRYPOINT !!
+async function createAssociation(association: Association, tezos: TezosToolkit): Promise<Operation> {
+  const contract = await tezos.contract.at(address);
+  const op: Operation = await contract.methodsObject.createAssociation(association).send();
+
+  await op.confirmation();
+  return op;
+}
+
+// NEED UPDATE ENTRYPOINT !!
+async function joinAssociation(associationName: string, tezos: TezosToolkit): Promise<Operation> {
+    const contract = await tezos.contract.at(address);
+    const op: Operation = await contract.methodsObject.joinAssociation(associationName).send();
+  
+    await op.confirmation();
+    return op;
+  }
+
+export { createAssociation }
\ No newline at end of file

src/services/getBalance.ts → src/services/balance.service.ts

 import { TezosToolkit } from "@taquito/taquito";
 
-async function getBalance(tezos: TezosToolkit) {
+async function getBalance(tezos: TezosToolkit): Promise<number> {
     try {
         const balance = await tezos.tz.getBalance(await tezos.signer.publicKeyHash());
-        return balance.toNumber() / 1000000
+        return balance.toNumber() / 1000000;
     } catch (error) {
         console.error('Erreur lors de la récupération du solde:', error);
+        throw error;
     }
 }
 
-export { getBalance }
\ No newline at end of file
+export { getBalance };
\ No newline at end of file

src/services/createToken.ts

-function createToken(address: string, tezos: any) {
-  const planetRequest = {
-    name: "Earth",
-    coordinate: [0, 0, 0],
-    planet_type: ["Terrestrial"],
-    density: 1n
-  };
-  tezos.wallet.at(address)
-    .then(async (contract) => {
-      await contract.methods.discoverPlanet(planetRequest, contract.storage()).send();
-    })
-    .then((op) => {
-      console.log(`Hash: ${op.opHash}`);
-      return op.confirmation();
-    })
-    .then((result) => {
-        console.log(result);
-        if (result.completed) {
-            console.log(`Transaction correctly processed!
-            Block: ${result.block.header.level}
-            Chain ID: ${result.block.chain_id}`);
-        } else {
-            console.log('An error has occurred');
-        }
-    })
-    .catch((err) => console.log(err));
-  }
-
-export { createToken }
\ No newline at end of file

src/services/proposal.service.ts

+import { Operation, TezosToolkit } from '@taquito/taquito';
+import { Proposal } from '../types/Proposal';
+
+// NEED UPDATE ADDRESS !!
+const address = "KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu"
+
+// NEED UPDATE ENTRYPOINT !!
+async function createProposal(proposal: Proposal, tezos: TezosToolkit): Promise<Operation> {
+  const contract = await tezos.contract.at(address);
+  const op: Operation = await contract.methodsObject.createProposal(proposal).send();
+
+  await op.confirmation();
+  return op;
+}
+
+export { createProposal }
\ No newline at end of file

src/services/token.service.ts

+import { Operation, TezosToolkit } from '@taquito/taquito';
+
+// NEED UPDATE ADDRESS !!
+const address = "KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu"
+
+// NEED UPDATE ENTRYPOINT !!
+async function createFAToken(tezos: TezosToolkit): Promise<Operation> {
+  const contract = await tezos.contract.at(address);
+  const op: Operation = await contract.methodsObject.destroyPlanet("Saturne").send();
+
+  await op.confirmation();
+  return op;
+}
+
+export { createFAToken }
\ No newline at end of file

src/types/Association.ts

+export type Association = {
+    name: string;
+    description: string;
+    tokenReference: string;
+    entranceFee?: number;
+}
\ No newline at end of file

src/types/Proposal.ts

+export type Proposal = {
+    title: string;
+    description: string;
+    fct: () => void;
+}
\ No newline at end of file

src/types/Role.ts

+export type Role = "ADMIN" | "ADHERENT" | "CONNECTED"
\ No newline at end of file

test/services/balance.service.spec.ts

+import { TezosToolkit } from "@taquito/taquito";
+import { getBalance } from "../../src/services/balance.service";
+import { vi, describe, it, expect } from 'vitest';
+
+const FAKE_PUBLIC_HASH_KEY = 'tz1abc123def456';
+
+describe('getBalance', () => {
+  it('should return the balance', async () => {
+    const mockedTezosToolkit = {
+      tz: {
+        getBalance: vi.fn().mockResolvedValue({ toNumber: () => 1000000000 })
+      },
+      signer: {
+        publicKeyHash: vi.fn().mockResolvedValue(FAKE_PUBLIC_HASH_KEY)
+      }
+    } as unknown as TezosToolkit;
+
+    const balance = await getBalance(mockedTezosToolkit);
+
+    expect(balance).toEqual(1000); // 1000000000 / 1000000 = 1000 tez
+    expect(mockedTezosToolkit.tz.getBalance).toHaveBeenCalledWith(FAKE_PUBLIC_HASH_KEY);
+  });
+
+  it('should throw an error if getting the balance fails', async () => {
+    const mockedTezosToolkit = {
+      tz: {
+        getBalance: vi.fn().mockRejectedValue(new Error('Failed to get balance'))
+      },
+      signer: {
+        publicKeyHash: vi.fn().mockResolvedValue(FAKE_PUBLIC_HASH_KEY)
+      }
+    } as unknown as TezosToolkit;
+
+    await expect(getBalance(mockedTezosToolkit)).rejects.toThrowError('Failed to get balance');
+    expect(mockedTezosToolkit.tz.getBalance).toHaveBeenCalledWith(FAKE_PUBLIC_HASH_KEY);
+  });
+});

test/services/token.service.spec.ts

+import { TezosToolkit } from '@taquito/taquito';
+import { createFAToken } from '../../src/services/token.service';
+import { vi, describe, it, expect, MockedClass } from 'vitest';
+
+const mockedTezosToolkit = {
+  contract: {
+    at: vi.fn().mockResolvedValue({
+      methodsObject: {
+        destroyPlanet: vi.fn().mockReturnValue({
+          send: vi.fn().mockResolvedValue({
+            confirmation: vi.fn().mockResolvedValue({})
+          })
+        })
+      }
+    })
+  }
+} as unknown as MockedClass<typeof TezosToolkit>;
+
+describe('createFAToken', () => {
+  it('should create a token successfully', async () => {
+    const result = await createFAToken(mockedTezosToolkit as unknown as TezosToolkit);
+
+    expect(mockedTezosToolkit.contract.at).toHaveBeenCalledWith("KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu");
+  });
+
+  it('should handle failure to create a token', async () => {
+    const mockedRejectedTezosToolkit = {
+      contract: {
+        at: vi.fn().mockRejectedValue(new Error('Contract not found'))
+      }
+    } as unknown as MockedClass<typeof TezosToolkit>;
+
+    let error: Error | undefined;
+    try {
+      await createFAToken(mockedRejectedTezosToolkit as unknown as TezosToolkit);
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error).toBeDefined();
+    expect(error?.message).toBe('Contract not found');
+  });
+});