puty 0.0.1 → 0.0.2

package/README.md

@@ -26,6 +26,8 @@ It should run all the tests in the file.
 
 ## Usage
 
+### Testing Functions
+
 ```yaml
 file: './math.js'
 group: math
@@ -61,3 +63,60 @@ in:
   - 2
 out: 3
 ```
+
+### Testing Classes
+
+Puty also supports testing classes with method calls and state assertions:
+
+```yaml
+file: './calculator.js'
+group: Calculator
+suites: [basic-operations]
+---
+suite: basic-operations
+mode: 'class'
+exportName: default
+constructorArgs: [10]  # Initial value
+---
+case: add and multiply operations
+executions:
+  - method: add
+    in: [5]
+    out: 15
+    asserts:
+      - property: value
+        op: eq
+        value: 15
+  - method: multiply
+    in: [2]
+    out: 30
+    asserts:
+      - property: value
+        op: eq
+        value: 30
+      - method: getValue
+        in: []
+        out: 30
+```
+
+#### Class Test Structure
+
+- `mode: 'class'` - Indicates this suite tests a class
+- `constructorArgs` - Arguments passed to the class constructor
+- `executions` - Array of method calls to execute in sequence
+  - `method` - Name of the method to call
+  - `in` - Arguments to pass to the method
+  - `out` - Expected return value (optional)
+  - `asserts` - Assertions to run after the method call
+    - Property assertions: Check instance properties
+    - Method assertions: Call methods and check their return values
+
+### Error Testing
+
+You can test that functions or methods throw expected errors:
+
+```yaml
+case: divide by zero
+in: [10, 0]
+throws: "Division by zero"
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puty",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A tooling function to test javascript functions and classes.",
   "main": "src/index.js",
   "type": "module",
@@ -19,5 +19,8 @@
     "lint": "bunx prettier src tests -c",
     "lint:fix": "bunx prettier src tests -w",
     "build": "bun run esbuild.js"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.1"
   }
 }

package/src/puty.js

@@ -36,12 +36,27 @@ export const parseYamlDocuments = (yamlContent) => {
         exportName: doc.exportName || doc.suite,
         cases: [],
       };
+      // Only add mode and constructorArgs if mode is explicitly 'class'
+      if (doc.mode === "class") {
+        currentSuite.mode = "class";
+        currentSuite.constructorArgs = doc.constructorArgs || [];
+      }
     } else if (doc.case && currentSuite) {
-      currentSuite.cases.push({
+      const testCase = {
         name: doc.case,
-        in: doc.in || [],
-        out: doc.out,
-      });
+      };
+
+      if (currentSuite.mode === "class") {
+        testCase.executions = doc.executions || [];
+      } else {
+        testCase.in = doc.in || [];
+        testCase.out = doc.out;
+        if (doc.throws) {
+          testCase.throws = doc.throws;
+        }
+      }
+
+      currentSuite.cases.push(testCase);
     }
   }
 
@@ -64,28 +79,111 @@ const setupTestSuite = (testConfig) => {
   describe(group, () => {
     for (const suite of suites) {
       describe(suite.name, () => {
-        const { cases } = suite;
-        for (const testCase of cases) {
-          const {
-            name,
-            in: inArg,
-            out: expectedOut,
-            functionUnderTest,
-          } = testCase;
-          test(name, () => {
-            const out = functionUnderTest(...(inArg || []));
-            if (out instanceof Error) {
-              expect(out.message).toEqual(out.message);
-            } else {
-              expect(out).toEqual(expectedOut);
-            }
-          });
+        const { cases, mode } = suite;
+
+        if (mode === "class") {
+          setupClassTests(suite);
+        } else {
+          setupFunctionTests(suite);
         }
       });
     }
   });
 };
 
+const setupFunctionTests = (suite) => {
+  const { cases } = suite;
+  for (const testCase of cases) {
+    const {
+      name,
+      in: inArg,
+      out: expectedOut,
+      functionUnderTest,
+      throws,
+    } = testCase;
+    test(name, () => {
+      if (!functionUnderTest) {
+        throw new Error(`Function not found for test case: ${name}`);
+      }
+
+      if (throws) {
+        // Test expects an error to be thrown
+        expect(() => functionUnderTest(...(inArg || []))).toThrow(throws);
+      } else {
+        const out = functionUnderTest(...(inArg || []));
+        expect(out).toEqual(expectedOut);
+      }
+    });
+  }
+};
+
+const setupClassTests = (suite) => {
+  const { cases, ClassUnderTest, constructorArgs } = suite;
+  for (const testCase of cases) {
+    const { name, executions } = testCase;
+    test(name, () => {
+      if (!ClassUnderTest) {
+        throw new Error(`Class not found for test suite: ${suite.name}`);
+      }
+
+      const instance = new ClassUnderTest(...constructorArgs);
+
+      for (const execution of executions) {
+        const {
+          method,
+          in: inArg,
+          out: expectedOut,
+          throws,
+          asserts,
+        } = execution;
+
+        // Validate method exists
+        if (!instance[method] || typeof instance[method] !== "function") {
+          throw new Error(`Method '${method}' not found on class instance`);
+        }
+
+        // Execute the method and check its return value
+        if (throws) {
+          expect(() => instance[method](...(inArg || []))).toThrow(throws);
+        } else {
+          const result = instance[method](...(inArg || []));
+          if (expectedOut !== undefined) {
+            expect(result).toEqual(expectedOut);
+          }
+        }
+
+        // Run assertions
+        if (asserts) {
+          for (const assertion of asserts) {
+            if (assertion.property) {
+              // Property assertion
+              const actualValue = instance[assertion.property];
+              if (assertion.op === "eq") {
+                expect(actualValue).toEqual(assertion.value);
+              }
+              // Add more operators as needed
+            } else if (assertion.method) {
+              // Method assertion
+              if (
+                !instance[assertion.method] ||
+                typeof instance[assertion.method] !== "function"
+              ) {
+                throw new Error(
+                  `Method '${assertion.method}' not found on class instance for assertion`,
+                );
+              }
+              const result = instance[assertion.method](
+                ...(assertion.in || []),
+              );
+              expect(result).toEqual(assertion.out);
+            }
+          }
+        }
+      }
+    });
+  }
+};
+
 /**
  *
  * @param {*} module
@@ -97,11 +195,27 @@ export const injectFunctions = (module, originalTestConfig) => {
   let functionUnderTest = module[testConfig.exportName || "default"];
 
   for (const suite of testConfig.suites) {
-    if (suite.exportName) {
-      functionUnderTest = module[suite.exportName];
-    }
-    for (const testCase of suite.cases) {
-      testCase.functionUnderTest = functionUnderTest;
+    if (suite.mode === "class") {
+      const exportName = suite.exportName || "default";
+      const exported = module[exportName];
+      if (!exported) {
+        throw new Error(
+          `Export '${exportName}' not found in module for class suite '${suite.name}'`,
+        );
+      }
+      suite.ClassUnderTest = exported;
+    } else {
+      if (suite.exportName) {
+        functionUnderTest = module[suite.exportName];
+        if (!functionUnderTest) {
+          throw new Error(
+            `Export '${suite.exportName}' not found in module for suite '${suite.name}'`,
+          );
+        }
+      }
+      for (const testCase of suite.cases) {
+        testCase.functionUnderTest = functionUnderTest;
+      }
     }
   }
   return testConfig;