@dicelette/core 1.0.0

package/tests/verify_template.test.ts

@@ -0,0 +1,244 @@
+// FILEPATH: /c:/Users/simonettili/Documents/Github/discord-dicelette/src/utils/verify_template.test.ts
+import { StatisticalTemplate } from "../core/interface";
+import { generateStatsDice, replaceFormulaInDice } from "../core/utils";
+import { diceRandomParse,evalCombinaison, generateRandomStat,testCombinaison, testDamageRoll, verifyTemplateValue } from "../core/verify_template";
+
+describe("verify_template", () => {
+	describe("evalCombinaison", () => {
+		it("should evaluate the combination correctly", () => {
+			const combinaison = { stat1: "stat2 + 3" };
+			const stats = { stat2: 2 };
+			const result = evalCombinaison(combinaison, stats);
+			expect(result).toEqual({ stat1: 5 });
+		});
+
+		it("should throw an error for invalid formula", () => {
+			const combinaison = { stat1: "stat2 + " };
+			const stats = { stat2: 2 };
+			expect(() => evalCombinaison(combinaison, stats)).toThrow();
+		});
+	});
+
+	describe("verifyRandomGenerator", () => {
+		// Add more tests for different scenarios
+		it("should verify the random generator correctly", () => {
+			const total = 100;
+			const max = 50;
+			const min = 10;
+			const result = generateRandomStat(total, max, min);
+			expect(result).toBeGreaterThanOrEqual(min);
+			expect(result).toBeLessThanOrEqual(max);
+			expect(result).toBeLessThanOrEqual(total);
+		});
+		
+		it ("should verify with no max", () => {
+			const total = 100;
+			const min = 1;
+			const result = generateRandomStat(total, undefined, min);
+			expect(result).toBeGreaterThanOrEqual(min);
+			expect(result).toBeLessThanOrEqual(total);
+		});
+
+		it ("should verify with no min", () => {
+			const total = 100;
+			const max = 99;
+			const result = generateRandomStat(total, max, undefined);
+			expect(result).toBeGreaterThanOrEqual(0);
+			expect(result).toBeLessThanOrEqual(max);
+		});
+
+		it ("should verify with no min and max", () => {
+			const total = 100;
+			const result = generateRandomStat(total, undefined, undefined);
+			expect(result).toBeGreaterThanOrEqual(0);
+			expect(result).toBeLessThanOrEqual(total);
+		});
+
+		it ("should verify with no total", () => {
+			const max = 99;
+			const min = 1;
+			const result = generateRandomStat(undefined, max, min);
+			expect(result).toBeGreaterThanOrEqual(min);
+			expect(result).toBeLessThanOrEqual(max);
+		});
+
+		it ("should verify with no total, min and max", () => {
+			const result = generateRandomStat(undefined, undefined, undefined);
+			expect(result).toBeGreaterThanOrEqual(0);
+			expect(result).toBeLessThanOrEqual(100);
+		});
+	});
+
+	describe("verifyTemplateValue", () => {
+		// Add more tests for different scenarios
+		it("should verify the template correctly", () => {
+			const template = {
+				statistics: { stat1: { max: 10, min: 1 } },
+				diceType: "1d20+{{ceil(($-10)/2)}}>20",
+				damage: {
+					"piercing": "1d6+2",
+				}
+			};
+			const result = verifyTemplateValue(template);
+			expect(result).toEqual(template);
+		});
+
+		it("testing no statistic, only damage", () => {
+			const template = {
+				diceType: "d6",
+				damage: {
+					"piercing": "1d6+2>20",
+				}
+			};
+			const result = verifyTemplateValue(template);
+			expect(result).toEqual(template);
+		});
+
+		it("should throw an error for invalid dice type", () => {
+			const template = {
+				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
+				diceType: "invalid",
+			};
+			expect(() => verifyTemplateValue(template)).toThrow();
+		});
+	});
+
+	describe("combinaison", () => {
+		// Add more tests for different scenarios
+		it("should throw an error because they are no stat2", () => {
+			const template: StatisticalTemplate = {
+				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
+				diceType: "d6",
+			};
+			expect(() => testCombinaison(template)).toThrow();
+		});
+		it("validate formula for dice", () => {
+			const template: StatisticalTemplate = {
+				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
+				diceType: "d6+{{$}}>20",
+			};
+			expect(() => testCombinaison(template)).toThrow();
+		});
+		it("validate formula for dice", () => {
+			const template: StatisticalTemplate = {
+				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
+				diceType: "d6+5>{{$}}",
+			};
+			expect(() => testCombinaison(template)).toThrow();
+		});
+		
+
+		
+		
+		it("create combinaison dice formula for skill dice with statistic", () => {
+			const testTemplate: StatisticalTemplate = {
+				statistics: { stat1: { max: 10, min: 1 } },
+				diceType: "1d20",
+				damage: {
+					"piercing": "1d6 + stat1>stat1",
+				}
+			};
+			const expectedFormula = diceRandomParse("1d20 + {{ceil((stat1-10)/2)}}>stat1", testTemplate);
+			expect(expectedFormula).toEqual(expectedFormula);
+		});
+		it("Test a roll with a combinaison on the dice", () => {
+			const template: StatisticalTemplate = {
+				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
+				diceType: "1d20",
+				damage: {
+					"piercing": "1d20stat1*2>stat1",
+				}
+			};
+			expect(() => testDamageRoll(template)).not.toThrow();
+		});
+		it("Test a roll with a combinaison on the dice and accents", () => {
+			const template: StatisticalTemplate = {
+				statistics: { éducation: { max: 10, min: 1 } },
+				diceType: "1d20",
+				damage: {
+					"piercing": "1déducation>20",
+				}
+			};
+			expect(() => testDamageRoll(template)).not.toThrow();
+		});
+	});
+	describe("roll_string_creation", () => {
+		it("creating roll dice with formula", () => {
+			const dice = "1d20+$>20";
+			const userStat = 10;
+			const calculation = replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
+			const formula = `${calculation} coucou`;
+			const expectedFormula = "1d20+10>20 coucou";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("creating roll dice with success formula", () => {
+			const dice = "1d20+5>{{$*2}}";
+			const userStat = 10;
+			const calculation = replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
+			const formula = `${calculation} coucou`;
+			const expectedFormula = "1d20+5>20 coucou";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("creating roll dice with complicated formula", () => {
+			const dice = "1d20+{{ceil((10-$)/2)}}>20";
+			const userStat = 5;
+			const calculation = replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
+			const formula = `${calculation} coucou`;
+			const expectedFormula = "1d20+3>20 coucou";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("creating roll dice with negative formula", () => {
+			const dice = "1d20+{{ceil(($-10)/2)}}>20";
+			const userStat = 5;
+			const calculation = replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
+			const expectedFormula = "1d20-2>20";
+			expect(calculation).toEqual(expectedFormula);
+		});
+	});
+	describe("skill_dice_creation", () => {
+		it("creating roll dice with face formula", () => {
+			let dice = "1dstat1>20";
+			const userStat = {
+				stat1: 5,
+				stat2: 10
+			};
+			dice = generateStatsDice(dice, userStat);
+			const formula = `${dice} cc`;
+			const expectedFormula = "1d5>20 cc";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("creating complicated roll dice with face formula", () => {
+			let dice = "1d20+{{ceil((stat1-10)/2)}}>20";
+			const userStat = {
+				stat1: 10,
+				stat2: 10
+			};
+			dice = generateStatsDice(dice, userStat);
+			const formula = `${dice} cc`;
+			const expectedFormula = "1d20+0>20 cc";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("create a simple dice adding bonus superior to stats", () => {
+			let dice = "1d20+stat1>stat1";
+			const userStat = {
+				stat1: 5,
+				stat2: 10
+			};
+			dice = generateStatsDice(dice, userStat);
+			const formula = `${dice} cc`;
+			const expectedFormula = "1d20+5>5 cc";
+			expect(formula).toEqual(expectedFormula);
+		});
+		it("creating complicated roll dice with comparator as formula", () => {
+			let dice = "1d20+stat1>{{ceil(stat1/2)}}";
+			const userStat = {
+				stat1: 5,
+				stat2: 10
+			};
+			dice = generateStatsDice(dice, userStat);
+			const formula = `${dice} cc`;
+			const expectedFormula = "1d20+5>3 cc";
+			expect(formula).toEqual(expectedFormula);
+		});
+	});
+});

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "commonjs",
+        "rootDir": "./",
+        "outDir": "./dist/",
+        "strict": true,
+        "moduleResolution": "node",
+        "importHelpers": true,
+        "experimentalDecorators": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowSyntheticDefaultImports": true,
+        "allowJs": true,
+        "checkJs": false,
+        "resolveJsonModule": true,
+        "forceConsistentCasingInFileNames": true,
+        "removeComments": true,
+        "typeRoots": [
+            "node_modules/@types"
+        ],
+        "sourceMap": false,
+        "baseUrl": "./"
+    },
+    "include": [
+        "./**/*.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ],
+}