puty 0.0.4-rc1 → 0.0.4

package/README.md

@@ -188,12 +188,12 @@ executions:
 - `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
+  - `method` - Name of the method to call (supports nested: `user.api.getData`)
   - `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
+    - Property assertions: Check instance properties (supports nested: `user.profile.name`)
+    - Method assertions: Call methods and check their return values (supports nested: `settings.getTheme`)
 
 ### Error Testing
 
@@ -387,21 +387,43 @@ For class tests:
 ```yaml
 case: 'test description'
 executions:
-  - method: 'methodName'
+  - method: 'methodName'        # Supports nested: 'user.api.getData'
     in: [arg1]
-    out: expectedValue    # Optional
-    throws: 'Error msg'   # Optional
+    out: expectedValue          # Optional
+    throws: 'Error msg'         # Optional
     asserts:
-      - property: 'prop'
-        op: 'eq'          # Currently only 'eq' is supported
+      - property: 'prop'        # Supports nested: 'user.profile.name'
+        op: 'eq'                # Currently only 'eq' is supported
         value: expected
-      - method: 'getter'
+      - method: 'getter'        # Supports nested: 'settings.ui.getTheme'
         in: []
         out: expected
-mocks:                    # Optional: Mocks for the entire test case
+mocks:                          # Optional: Mocks for the entire test case
   mockName:
     calls:
       - in: [args]
         out: result
 ```
 
+#### Nested Properties and Methods
+
+Puty supports accessing nested properties and calling nested methods using dot notation:
+
+```yaml
+case: 'test nested access'
+executions:
+  - method: 'settings.ui.setTheme'    # Call nested method
+    in: ['dark']
+    out: 'dark'
+    asserts:
+      - property: 'user.profile.name'    # Access nested property
+        op: eq
+        value: 'John Doe'
+      - property: 'user.account.balance' # Deep nested property
+        op: eq
+        value: 100.50
+      - method: 'api.client.get'         # Call nested method
+        in: ['/users/123']
+        out: 'GET /users/123'
+```
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puty",
-  "version": "0.0.4-rc1",
+  "version": "0.0.4",
   "description": "A tooling function to test javascript functions and classes.",
   "main": "src/index.js",
   "type": "module",

package/src/puty.js

@@ -11,6 +11,70 @@ import { expect, test, describe } from "vitest";
 import { traverseAllFiles, parseWithIncludes } from "./utils.js";
 import { resolveMocks, processMockReferences, createMockFunctions, validateMockCalls } from "./mockResolver.js";
 
+/**
+ * Resolves a nested property path on an object (e.g., "user.profile.name")
+ * @param {Object} obj - The object to traverse
+ * @param {string} path - The property path (e.g., "user.profile.name")
+ * @returns {any} The value at the path
+ * @throws {Error} If any part of the path doesn't exist
+ */
+const getNestedProperty = (obj, path) => {
+  const parts = path.split('.');
+  let current = obj;
+  
+  for (let i = 0; i < parts.length; i++) {
+    if (current == null) {
+      throw new Error(`Cannot access property '${parts[i]}' of ${current} in path '${path}'`);
+    }
+    if (!(parts[i] in current)) {
+      throw new Error(`Property '${parts[i]}' not found in path '${path}'`);
+    }
+    current = current[parts[i]];
+  }
+  
+  return current;
+};
+
+/**
+ * Resolves a nested method path and calls it (e.g., "user.api.getData")
+ * @param {Object} obj - The object to traverse
+ * @param {string} path - The method path (e.g., "user.api.getData")
+ * @param {Array} args - Arguments to pass to the method
+ * @returns {any} The result of the method call
+ * @throws {Error} If any part of the path doesn't exist or final part is not a function
+ */
+const callNestedMethod = (obj, path, args = []) => {
+  const parts = path.split('.');
+  const methodName = parts.pop();
+  
+  let current = obj;
+  const parentPath = parts.join('.');
+  
+  // Navigate to the parent object
+  for (const part of parts) {
+    if (current == null) {
+      throw new Error(`Cannot access property '${part}' of ${current} in path '${path}'`);
+    }
+    if (!(part in current)) {
+      throw new Error(`Property '${part}' not found in path '${path}'`);
+    }
+    current = current[part];
+  }
+  
+  // Check if the method exists and is a function
+  if (current == null) {
+    throw new Error(`Cannot access method '${methodName}' of ${current} in path '${path}'`);
+  }
+  if (!(methodName in current)) {
+    throw new Error(`Method '${methodName}' not found in path '${path}'`);
+  }
+  if (typeof current[methodName] !== 'function') {
+    throw new Error(`'${methodName}' is not a function in path '${path}'`);
+  }
+  
+  return current[methodName](...args);
+};
+
 /**
  * File extensions that are recognized as YAML test files
  * @type {string[]}
@@ -215,16 +279,11 @@ const setupClassTests = (suite) => {
             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
+          // Execute the method and check its return value - supports nested methods
           if (throws) {
-            expect(() => instance[method](...(inArg || []))).toThrow(throws);
+            expect(() => callNestedMethod(instance, method, inArg || [])).toThrow(throws);
           } else {
-            const result = instance[method](...(inArg || []));
+            const result = callNestedMethod(instance, method, inArg || []);
             if (expectedOut !== undefined) {
               expect(result).toEqual(expectedOut);
             }
@@ -234,25 +293,15 @@ const setupClassTests = (suite) => {
           if (asserts) {
             for (const assertion of asserts) {
               if (assertion.property) {
-                // Property assertion
-                const actualValue = instance[assertion.property];
+                // Property assertion - supports nested properties like "user.profile.name"
+                const actualValue = getNestedProperty(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 || []),
-                );
+                // Method assertion - supports nested methods like "user.api.getData"
+                const result = callNestedMethod(instance, assertion.method, assertion.in || []);
                 expect(result).toEqual(assertion.out);
               }
             }