New wrapper approach. Chain and Distinct.

Author: poing

javascript/wrapper.js

@@ -29,21 +29,29 @@ if (require.main === module) {
 	// The the commands to execute
 	const inputData = JSON.parse(commands);
 
+
 	// Debugging statements
-	//console.log("Commands received from Python:", commands);
+	//console.log("Commands received from Python:", inputData);
 	//console.log("inputData[0][0]: ", inputData[0][0]); // returns: init(33)
 
+
+	// Array to store results
+	let allResults = [];
+
 	// Loop through commands	
 	for (const command of inputData) {
 		// Evaluate each command
-		lastResult = eval('secrets.' + command);
+		//lastResult = eval('secrets.' + command);
+		const result = eval('secrets.' + command);
+		allResults.push(result);
 	}
 
 	// Return the result of the last command
-	console.log(JSON.stringify(lastResult));
+	//console.log(JSON.stringify(lastResult));
+	console.log(JSON.stringify(allResults));
 
   } catch (error) {
     console.error("Error executing command:", error.message);
     process.exit(1);
   }
-}
+}

js2pysecrets/decorators.py

@@ -1,44 +1,61 @@
-import json
 import types
 
-from .wrapper import wrapper  # Import your wrapper function
+from .wrapper import chain
 
 
 class JsFunction:
-    def __init__(self, func, test=False):
+    def __init__(self, func, test=False, distinct=False):
         self.func = func
         self.test = test
+        self.distinct = distinct
 
-    def __call__(self, *args, test=False, **kwargs):
+    def __call__(self, *args, test=False, distinct=False, **kwargs):
         def wrapped_func(*args, **kwargs):
             args_str = ", ".join(repr(arg) for arg in args)
 
             return f"{self.func.__name__}({args_str})"
 
-        data = []
+        if distinct or self.distinct:
+            return (
+                wrapped_func(*args, **kwargs)
+                if args
+                else self.func(*args, **kwargs)
+            )
+        else:
 
-        # DO NOT REMOVE THIS
-        if test or self.test:
-            data.append("setRNG('testRandom')")
+            data = []
 
-        data.append(
-            wrapped_func(*args, **kwargs)
-            if args
-            else self.func(*args, **kwargs)
-        )
+            # DO NOT REMOVE THIS
+            if test or self.test:
+                data.append("setRNG('testRandom')")
+
+            data.append(
+                wrapped_func(*args, **kwargs)
+                if args
+                else self.func(*args, **kwargs)
+            )
 
-        json_data = json.dumps(data, indent=None).replace("'", "`")
-        commands = json_data.encode().hex()
-        results = wrapper(commands)
+            # Break this section out into a stand-alone function
+            # json_data = json.dumps(data, indent=None).replace("'", "`")
+            # commands = json_data.encode().hex()
+            # results = wrapper(commands)
+            # End of section
 
-        return results
+            return get_last_element_or_string(chain(data))
 
     def __get__(self, instance, owner):
         return (
             self if instance is None else types.MethodType(self, instance)
         )  # pragma: no cover  No idea how to test!
 
 
+def get_last_element_or_string(result):
+    if isinstance(result, list):
+        return result[-1]
+    else:
+        return str(result)
+
+
 class jsNeedless:
     def __init__(self, func_name, test=False):
         self.func_name = func_name

js2pysecrets/node.py

@@ -17,6 +17,11 @@ def random(*args, **kwargs):
     pass  # pragma: no cover
 
 
+@JsFunction
+def foobar(*args, **kwargs):
+    pass  # pragma: no cover
+
+
 @JsFunction
 def getConfig(*args, **kwargs):
     pass  # pragma: no cover
@@ -27,13 +32,13 @@ def combine(*args, **kwargs):
     pass  # pragma: no cover
 
 
-@jsNeedless
+@JsFunction
 def init(*args, **kwargs):
     pass  # pragma: no cover
 
 
 @jsNeedless
-def newShare(*args, **kwargs):
+def _reset(*args, **kwargs):
     pass  # pragma: no cover
 
 

js2pysecrets/wrapper.py

@@ -68,8 +68,8 @@ def wrapper(input_data):
             return js_result
 
         except json.JSONDecodeError as e:
-            # print("Python error decoding JSON:", e)
-            # print("Raw stdout content:", result.stdout)
+            print("Python error decoding JSON:", e)
+            print("Raw stdout content:", result.stdout)
             warning_message = "Python error decoding JSON: " + str(e)
             warnings.warn(warning_message, category=Warning)
             return None
@@ -87,3 +87,10 @@ def wrapper(input_data):
         warning_message = "JavaScript error: " + js_error
         warnings.warn(warning_message, category=Warning)
         return None
+
+
+def chain(commands):
+    json_data = json.dumps(commands, indent=None).replace("'", "`")
+    encoded_commands = json_data.encode().hex()
+    results = wrapper(encoded_commands)
+    return results

tests/test_node.py

@@ -0,0 +1,108 @@
+from js2pysecrets.decorators import JsFunction, jsNeedless
+from js2pysecrets.wrapper import wrapper
+
+import js2pysecrets.node as node
+import pytest
+import warnings
+
+
+def not_supported(decorated_function):
+    try:
+        decorated_function()
+        # If the function didn't raise an exception, return False
+        return False
+    except Exception as e:
+        # If an exception was raised, ensure it matches the expected message
+        expected_message = (
+            "Calling subsequent JavaScript functions are not supported. -or- "
+            "The JavaScript function isn't necessary for the Python version."
+        )
+        return str(e) == expected_message
+
+
+@JsFunction
+def invalidFunction(*args, **kwargs):
+    pass
+
+
+@jsNeedless
+def needless(*args, **kwargs):
+    pass  # pragma: no cover
+
+
+def test_JsFunction():
+    assert node.random(128) != node.random(32)
+
+
+def test_jsNeedless():
+    assert not_supported(lambda: needless(33, "blue"))
+
+
+def test_Distinct():
+    command = node.share("aabb", 6, 3, distinct=True)
+    assert command == "share('aabb', 6, 3)"
+
+
+def test_Randomness():
+    count = 0
+    num_trials = 10
+    for _ in range(num_trials):
+        # Simulate random behavior
+        rand1 = node.random(16)
+        rand2 = node.random(16)
+        if int(rand1, 16) == int(rand2, 16):
+            count += 1
+    assert count < num_trials, "Randomness test failed"
+
+
+def test_TestRNG():
+    count = 0
+    num_trials = 10
+    for _ in range(num_trials):
+        # Simulate random behavior
+        rand1 = node.random(16, test=True)
+        rand2 = node.random(16, test=True)
+        if int(rand1, 16) == int(rand2, 16):
+            count += 1
+    assert count == num_trials, "Test RNG Failed"
+
+
+@pytest.mark.filterwarnings("ignore:invalidFunction")
+def test_invalidFunction():
+    with warnings.catch_warnings(record=True) as caught_warnings:
+        invalidFunction(1, 2, 3)
+        # Check if any warnings were raised
+        assert len(caught_warnings) == 1
+        assert issubclass(caught_warnings[0].category, Warning)
+        assert "not a function" in str(caught_warnings[0].message)
+
+
+@pytest.mark.filterwarnings("ignore:node.share")
+def test_CalledProcessError():
+    with warnings.catch_warnings(record=True) as caught_warnings:
+        node.share("hello world", 3, 3)
+        # Check if any warnings were raised
+        assert len(caught_warnings) == 1
+        assert issubclass(caught_warnings[0].category, Warning)
+        assert "Invalid hex character" in str(caught_warnings[0].message)
+
+
+# @pytest.mark.filterwarnings("ignore:fail")
+# def test_JSONDecodeError():
+#     with warnings.catch_warnings(record=True) as caught_warnings:
+#         node.fail()
+#         # Check if any warnings were raised
+#         assert len(caught_warnings) == 1
+#         assert issubclass(caught_warnings[0].category, Warning)
+#         assert "error decoding JSON" in str(caught_warnings[0].message)
+
+
+# @pytest.mark.filterwarnings("ignore:wrapper")
+# def test_JSONDecodeError():
+#     with warnings.catch_warnings(record=True) as caught_warnings:
+#         wrapper("hello world")
+#         # Check if any warnings were raised
+#         assert len(caught_warnings) == 1
+#         assert issubclass(caught_warnings[0].category, Warning)
+#         assert "error decoding JSON" in str(caught_warnings[0].message)
+#         # assert True