additional Testing with tests derived from xstate.core 4.25

.github/workflows/pull_request.yaml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9]
+        python-version: [3.7, 3.8, 3.9]
         poetry-version: [1.1.6]
         os: [ubuntu-latest]
     runs-on: ${{ matrix.os }}

pyproject.toml

@@ -9,7 +9,6 @@ keywords = ["Answer Set Programming", "wrapper", "clingo"]
 classifiers = [
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9"
@@ -22,8 +21,9 @@ packages = [
 docs = "https://github.com/davidkpiano/xstate-python"
 
 [tool.poetry.dependencies]
-python = "^3.6.2"
+python = "^3.7.0"
 Js2Py = "^0.71"
+anytree = "^2.8.0"
 
 [tool.poetry.dev-dependencies]
 pytest-cov = "^2.12.0"

tests/test_algorithm.py

@@ -1,7 +1,174 @@
-from xstate.algorithm import is_parallel_state
+"""Tests for  algorithms
+
+These tests use either machines coded as python `dict` 
+or accept strings representing xstate javascript/typescript which are
+then converted to a python `dict` by the module `js2py`
+
+The following tests exist
+    * test_is_parallel_state - returns the column headers of the file
+    * test_is_not_parallel_state - the main function of the script
+"""
+
+import pytest
+from .utils_for_tests import pytest_func_docstring_summary
+
+
+from xstate.algorithm import is_parallel_state, to_state_path, get_configuration
 from xstate.machine import Machine
 
 
+class TestAlgorithms:
+
+    test_machine = Machine(
+        """    {
+            id: 'a',
+            initial: 'b1',
+            states: {
+                b1: {
+                id: 'b1',
+                type: 'parallel',
+                states: {
+                    c1: {
+                    id: 'c1',
+                    initial: 'd1',
+                    states: {
+                        d1: { id: 'd1' },
+                        d2: {
+                        id: 'd2',
+                        initial: 'e1',
+                        states: {
+                            e1: { id: 'e1' },
+                            e2: { id: 'e2' }
+                        }
+                        }
+                    }
+                    },
+                    c2: { id: 'c2' },
+                    c3: {
+                    id: 'c3',
+                    initial: 'd3',
+                    states: {
+                        d3: { id: 'd3' },
+                        d4: {
+                        id: 'd4',
+                        initial: 'e3',
+                        states: {
+                            e3: { id: 'e3' },
+                            e4: { id: 'e4' }
+                        }
+                        }
+                    }
+                    }
+                }
+                },
+                b2: {
+                id: 'b2',
+                initial: 'c4',
+                states: {
+                    c4: { id: 'c4' }
+                }
+                },
+                b3: {
+                id: 'b3',
+                initial: 'c5',
+                states: {
+                    c5: { id: 'c5' },
+                    c6: {
+                    id: 'c6',
+                    type: 'parallel',
+                    states: {
+                        d5: { id: 'd5' },
+                        d6: { id: 'd6' },
+                        d7: { id: 'd7' }
+                    }
+                    }
+                }
+                }
+            }
+            }
+        """
+    )
+
+    def test_algorithim_get_configuration(self, request):
+        """1 - getConfiguration
+
+        ref: https://github.com/statelyai/xstate/blob/main/packages/core/test/algorithm.test.ts
+        """
+        prev_nodes = self.test_machine.root.get_state_nodes(
+            # TODO: Should this be a config snippet `StateNode.get_state_nodes` does not decode dict
+            """    {
+                            b1: {
+                                c1: 'd1',
+                                c2: {},
+                                c3: 'd3'
+                            }
+                            }
+                        """
+        )
+        nodes = [self.test_machine.root.get_state_node_by_id(id) for id in ["c1", "d4"]]
+
+        c = get_configuration(prev_nodes, nodes)
+
+        assert sorted([sn.id for sn in c]) == [
+            "a",
+            "b1",
+            "c1",
+            "c2",
+            "c3",
+            "d1",
+            "d4",
+            "e3",
+        ], pytest_func_docstring_summary(request)
+
+
+def test_machine_config_translate():
+
+    xstate_js_config = """{
+                id: 'fan',
+                initial: 'off',
+                states: {
+                    off: {
+                    on: {
+                        POWER:'on.hist',
+                        H_POWER:'on.H',
+                        SWITCH:'on.first'
+                    }
+
+                    },
+                    on: {
+                    initial: 'first',
+                    states: {
+                        first: {
+                        on: {
+                            SWITCH:'second'
+                        }
+                        },
+                        second: {
+                        on: {
+                            SWITCH: 'third'
+                        }
+                        },
+                        third: {},
+                        H: {
+                        type: 'history'
+                        },
+                        hist: {
+                        type: 'history',
+                        history:'shallow'
+                        },
+                    }
+                    }
+                }
+        }
+        """
+    # xstate_python_config=machine_config_translate(xstate_js_config)
+    # assert isinstance(xstate_python_config,dict)
+    try:
+        machine = Machine(xstate_js_config)
+    except Exception as e:
+        assert False, f"Machine config is not valid, Exception:{e}"
+
+
 def test_is_parallel_state():
     machine = Machine(
         {"id": "test", "initial": "foo", "states": {"foo": {"type": "parallel"}}}
@@ -20,3 +187,19 @@ def test_is_not_parallel_state():
     foo_state_node = machine._get_by_id("test.foo")
 
     assert is_parallel_state(foo_state_node) is False
+
+
+class TestStatePaths:
+    def test__to_state_path(self, request):
+        """should have valid results for converstion to state paths list"""
+        assert to_state_path("one.two.three") == ["one", "two", "three"]
+        assert to_state_path("one/two/three", delimiter="/") == ["one", "two", "three"]
+        assert to_state_path(["one", "two", "three"]) == ["one", "two", "three"]
+        try:
+            state_id = {"values": ["one", "two", "three"]}
+            assert to_state_path(state_id) == ["one", "two", "three"]
+        except Exception as e:
+            assert (
+                e.args[0]
+                == "{'values': ['one', 'two', 'three']} is not a valid state path"
+            )