jaseci 1.4.2.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/extens/api/tests/test_global_api.py

@@ -1,179 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-from jaseci.jsorc.jsorc import JsOrc
-import jaseci.tests.jac_test_code as jtc
-
-
-class GlobalApiTest(CoreTest):
-    """Unit tests for Jac Global APIs"""
-
-    fixture_src = __file__
-
-    def setUp(self):
-        super().setUp()
-
-        self.smast2 = JsOrc.super_master(h=self.smast._h)
-        self.smast.sentinel_register(name="test", code=jtc.basic)
-
-        self.mast2 = JsOrc.master(h=self.mast._h)
-        self.mast.sentinel_register(name="test", code=jtc.basic)
-
-    def tearDown(self):
-        super().tearDown()
-
-    def test_sent_global_active(self):
-        """Test setting global sentinel"""
-        api = ["global_sentinel_set", {"snt": None}]
-        self.call(self.smast, api)
-        api = ["sentinel_active_global", {}]
-        self.call(self.smast2, api)
-        api = ["sentinel_list", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertEqual(len(r), 0)
-        api = ["sentinel_active_get", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertIn("jid", r.keys())
-        self.assertEqual(r["name"], "test")
-        api = ["sentinel_list", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertEqual(len(r), 0)
-
-    def test_sent_global_pull(self):
-        """Test setting global sentinel"""
-        api = ["global_sentinel_set", {"snt": None}]
-        self.call(self.smast, api)
-        api = ["sentinel_list", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertEqual(len(r), 0)
-        api = ["sentinel_pull", {}]
-        self.call(self.smast2, api)
-        api = ["sentinel_list", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertEqual(len(r), 1)
-        api = ["sentinel_active_get", {"detailed": False}]
-        r = self.call(self.smast2, api)
-        self.assertIn("jid", r.keys())
-        self.assertEqual(r["name"], "test")
-
-    def test_global_set_get_delete(self):
-        """Test setting global sentinel"""
-        api = ["global_get", {"name": "apple"}]
-        r = self.call(self.smast, api)
-        self.assertIsNone(r["value"])
-        api = ["global_set", {"name": "apple", "value": "56"}]
-        r = self.call(self.smast, api)
-        api = ["global_get", {"name": "apple"}]
-        r = self.call(self.smast2, api)
-        self.assertEqual(r["value"], "56")
-        api = ["global_delete", {"name": "apple"}]
-        r = self.call(self.smast2, api)
-        api = ["global_get", {"name": "apple"}]
-        r = self.call(self.smast, api)
-        self.assertIsNone(r["value"])
-
-    def test_user_create(self):
-        """Test master create operation"""
-        api = ["user_create", {"name": "yo@gmail.com"}]
-        r = self.call(self.mast, api)
-        self.assertIn("j_type", r["user"])
-        self.assertEqual(r["user"]["j_type"], "master")
-
-    def test_master_create(self):
-        """Test master create operation"""
-        api = ["master_create", {"name": "yo@gmail.com"}]
-        r = self.call(self.mast, api)
-        self.assertIn("j_type", r["user"])
-        self.assertEqual(r["user"]["j_type"], "master")
-
-    def test_master_create_error_out(self):
-        """Test master create operation"""
-        api = ["master_create", {"name": "yo@gmail.com"}]
-        r = self.call(self.mast, api)
-        api = ["master_create", {"name": "yo@gmail.com"}]
-        r = self.call(self.mast, api)
-        self.assertIn("response", r)
-        self.assertIn("already exists", r["response"])
-
-    def test_master_create_super_limited(self):
-        """Test master create operation"""
-        api = ["master_createsuper", {"name": "yo3@gmail.com"}]
-        r = self.call(self.mast, api)
-        self.assertIn("response", r)
-        self.assertIn("not a valid", r["response"])
-
-    def test_master_create_linked_super_master_create(self):
-        """Test master create operation"""
-        api = ["master_createsuper", {"name": "yo3@gmail.com"}]
-        r = self.call(self.smast, api)
-        self.assertIn("j_type", r["user"])
-        self.assertEqual(r["user"]["j_type"], "super_master")
-
-    def test_global_sentinel_set_unset(self):
-        api = ["global_sentinel_set", {}]
-        r = self.call(self.smast, api)
-        self.assertIn("response", r)
-        self.assertNotIn("error", r)
-        api = ["global_sentinel_unset", {}]
-        r = self.call(self.smast, api)
-        self.assertIn("response", r)
-        self.assertNotIn("error", r)
-
-    def test_global_sentinel_double_unset(self):
-        api = ["global_sentinel_set", {}]
-        r = self.call(self.smast, api)
-        self.assertIn("response", r)
-        self.assertNotIn("error", r)
-        api = ["global_sentinel_unset", {}]
-        r = self.call(self.smast, api)
-        self.assertIn("response", r)
-        self.assertNotIn("error", r)
-        api = ["global_sentinel_unset", {}]
-        r = self.call(self.smast, api)
-        self.assertIn("response", r)
-        self.assertNotIn("error", r)
-
-    def test_graph_node_set_mem_leak_fix(self):
-        api = ["graph_create", {}]
-        r = self.call(self.smast, api)
-        before = len(self.smast._h.mem)
-        jid = r["jid"]
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        api = ["graph_node_set", {"nd": jid, "ctx": {}}]
-        r = self.call(self.smast, api)
-        after = len(self.smast._h.mem)
-        self.assertEqual(before, after)
-
-    def test_mem_no_leak_creating_one_node_and_node_set(self):
-        mem_state = self.smast._h.mem
-        before = len(mem_state)
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-        self.assertEqual(len(mem_state) - before, 8)
-        before = len(mem_state)
-        r = self.call(
-            self.smast,
-            ["walker_run", {"name": "one_node"}],
-        )
-        jid = r["report"][0]["jid"]
-        self.assertEqual(len(mem_state) - before, 2)
-        before = len(mem_state)
-        self.call(
-            self.smast,
-            ["graph_node_set", {"nd": jid, "ctx": {"msg": "goodbye world"}}],
-        )
-        self.assertEqual(len(mem_state) - before, 0)
-        r = self.call(
-            self.smast,
-            ["graph_node_get", {"nd": jid}],
-        )
-        self.assertEqual(r["msg"], "goodbye world")

jaseci/extens/api/tests/test_graph_api.py

@@ -1,64 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class GraphApiTest(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_graph_depth(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("fam.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "create_fam"}])
-        ret = self.call(self.mast, ["graph_get", {}])
-        self.assertEqual(len(ret), 9)
-        ret = self.call(self.mast, ["graph_get", {"depth": 2}])
-
-        # old approach will include married edge
-        # but it shouldn't since it's considered a 3rd step
-        self.assertEqual(len(ret), 5)
-        ret = self.call(self.mast, ["graph_get", {"depth": 1}])
-        self.assertEqual(len(ret), 1)
-
-    def test_graph_node_view(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("fam.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "create_fam"}])
-        ret = self.call(self.mast, ["graph_get", {}])
-        self.assertEqual(len(ret), 9)
-        ret = self.call(self.mast, ["graph_node_view", {"show_edges": True}])
-        self.assertEqual(len(ret), 5)
-        ret = self.call(self.mast, ["graph_node_view", {}])
-        self.assertEqual(len(ret), 3)
-
-    def test_graph_node_view_filters(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("fam.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "create_fam"}])
-        ret = self.call(self.mast, ["graph_node_view", {"node_type": "man"}])
-        self.assertEqual(len(ret), 2)
-        jid = ret[1]["jid"]
-        ret = self.call(self.mast, ["graph_node_view", {"nd": jid, "show_edges": True}])
-        self.assertEqual(len(ret), 7)
-        ret = self.call(
-            self.mast,
-            [
-                "graph_node_view",
-                {"nd": jid, "show_edges": False, "edge_type": "married"},
-            ],
-        )
-        self.assertEqual(len(ret), 2)
-        ret = self.call(
-            self.mast,
-            [
-                "graph_node_view",
-                {"nd": jid, "show_edges": True, "edge_type": "married"},
-            ],
-        )
-        self.assertEqual(len(ret), 3)

jaseci/extens/api/tests/test_logger_api.py

@@ -1,43 +0,0 @@
-from jaseci.utils.log_utils import LimitedSlidingBuffer, parse_logs
-from jaseci.utils.test_core import CoreTest
-
-
-class LoggerApiTest(CoreTest):
-    fixture_src = __file__
-
-    logs = [
-        "2022-11-26 21:43:55,354 - ERROR - start: Skipping MailService due to initialization failure!",
-        "ConnectionRefusedError: [Errno 61] Connection refused",
-    ]
-
-    def test_parse_logs(self):
-        parsed_logs = parse_logs(self.logs)
-
-        self.assertEqual(len(parsed_logs), 2)
-
-        self.assertEqual(parsed_logs[0]["level"], "ERROR")
-        self.assertEqual(parsed_logs[1]["level"], None)
-
-        self.assertEqual(parsed_logs[0]["date"], "2022-11-26 21:43:55")
-        self.assertEqual(parsed_logs[1]["date"], None)
-
-    def test_get_logs(self):
-        self.logger_on()
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("test_logging.jac")}],
-        )
-        self.logger_off()
-
-        ret = self.call(self.smast, ["logger_get", {}])
-        self.assertGreaterEqual(len(ret), 1)
-        self.assertTrue(ret[-1]["log"].endswith("Hello world!"))
-
-    def test_limited_sliding_buffer(self):
-        buffer = LimitedSlidingBuffer(max_size=25)
-        buffer.write("Hello world!")
-        buffer.write("Hi there!")
-        buffer.write("Hello world!")
-        buffer.write("Hi there!")
-        self.assertEqual(buffer.getvalue(), "ere!Hello world!Hi there!")
-        self.assertEqual(buffer.current_size, 25)

jaseci/extens/api/tests/test_object_api.py

@@ -1,20 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class ObjectApiTest(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_object_set(self):
-        ret = self.call(
-            self.mast,
-            [
-                "object_set",
-                {"obj": self.mast.jid, "ctx": {"name": "MYNEWNAME", "jid": "MYNEWJID"}},
-            ],
-        )
-        self.assertEqual(ret["name"], "MYNEWNAME")
-        self.assertNotEqual(ret["jid"], "MYNEWJID")
-        self.assertEqual(self.mast.name, "MYNEWNAME")
-        self.assertNotEqual(self.mast.jid, "MYNEWJID")

jaseci/extens/api/tests/test_sentinel_api.py

@@ -1,66 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class SentinelApiTest(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_auto_run_when_synced_to_global(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-        self.call(
-            self.smast,
-            ["global_sentinel_set", {}],
-        )
-        ret = self.call(
-            self.mast,
-            [
-                "sentinel_active_global",
-                {
-                    "auto_run": "init",
-                    "auto_run_ctx": {"wrld": "jason"},
-                    "auto_create_graph": True,
-                },
-            ],
-        )
-        num_gphs = len(self.call(self.mast, ["graph_list", {}]))
-        self.assertEqual(ret["auto_run_result"]["report"], ["hello jason!"])
-        self.assertEqual(num_gphs, 1)
-
-    def test_auto_run_when_synced_to_global_multi(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-        self.call(
-            self.smast,
-            ["global_sentinel_set", {}],
-        )
-        self.call(
-            self.mast,
-            [
-                "sentinel_active_global",
-                {
-                    "auto_run": "init",
-                    "auto_run_ctx": {"wrld": "jason"},
-                    "auto_create_graph": True,
-                },
-            ],
-        )
-        ret = self.call(
-            self.mast,
-            [
-                "sentinel_active_global",
-                {
-                    "auto_run": "init",
-                    "auto_run_ctx": {"wrld": "jason"},
-                    "auto_create_graph": True,
-                },
-            ],
-        )
-        num_gphs = len(self.call(self.mast, ["graph_list", {}]))
-        self.assertEqual(ret["auto_run_result"]["report"], ["hello jason!"])
-        self.assertEqual(num_gphs, 2)

jaseci/extens/api/tests/test_uncommon.py

@@ -1,107 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class UncommonImplementationTest(CoreTest):
-    """Unit tests for Uncommon Implementaion APIs"""
-
-    fixture_src = __file__
-
-    def test_overrided_action_ability(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("action_override.jac")}],
-        )
-
-        reports = self.call(self.smast, ["walker_run", {"name": "check"}])["report"]
-        keys = [
-            "log",
-            "out",
-            "js_input",
-            "input",
-            "js_round",
-            "round",
-            "err",
-            "sleep",
-            "sort_by_col",
-            "time_now",
-            "set_global",
-            "get_global",
-            "actload_local",
-            "actload_remote",
-            "actload_module",
-            "destroy_global",
-            "set_perms",
-            "get_perms",
-            "grant_perms",
-            "revoke_perms",
-            "get_report",
-            "clear_report",
-            "log_activity",
-        ]
-        for key in keys:
-            # node tester - testing first report: std should be the default
-            self.assertIsInstance(reports[0][key], dict)
-            self.assertEqual(reports[0][key]["name"], f"std.{key}")
-            self.assertEqual(reports[0][key]["kind"], "ability")
-
-            # walker check - tester report: std should be the default
-            self.assertIsInstance(reports[3][key], dict)
-            self.assertEqual(reports[3][key]["name"], f"std.{key}")
-            self.assertEqual(reports[3][key]["kind"], "ability")
-
-            # node tester - testing after std.set_global = 1
-            # all actions should be the same except std.set_global
-            if key != "set_global":
-                self.assertIsInstance(reports[1][key], dict)
-                self.assertEqual(reports[1][key]["name"], f"std.{key}")
-                self.assertEqual(reports[1][key]["kind"], "ability")
-
-        self.assertIsInstance(reports[1]["set_global"], int)
-        self.assertEqual(reports[1]["set_global"], 1)
-
-        # node tester - testing third report: std set to 1
-        self.assertEqual(reports[2], 1)
-
-    def test_node_ability_from_global_sentinel(self):
-        self.call(self.mast, ["graph_create", {}])
-
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("uncommon_impl.jac")}],
-        )
-
-        self.call(self.smast, ["global_sentinel_set", {}])
-        self.call(self.mast, ["sentinel_active_global", {}])
-
-        res = self.call(self.smast, ["walker_run", {"name": "check_ability"}])
-        self.assertEqual("super_master", res["report"][0]["j_type"])
-        self.assertEqual([], res["report"][1])
-
-        # since admin already create `with_ability` node on init,
-        # it should not have `inner_node`
-        res = self.call(self.smast, ["walker_run", {"name": "check_ability"}])
-        self.assertEqual("super_master", res["report"][0]["j_type"])
-        self.assertEqual(0, len(res["report"][1]))
-
-        # users should be able to access their inner nodes inside ability
-        res = self.call(self.mast, ["walker_run", {"name": "check_ability"}])
-        # before it will return the owner of the sentinel which is the super_master
-        self.assertEqual("master", res["report"][0]["j_type"])
-        self.assertEqual(1, len(res["report"][1]))
-
-    def test_existing_node_in_graph_but_not_in_sentinel(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("with_node_b.jac")}],
-        )
-
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("without_node_b.jac")}],
-        )
-
-        res = self.call(self.smast, ["walker_run", {"name": "init"}])
-
-        self.assertTrue(res["success"])
-        self.assertEqual(1, len(res["report"]))
-        self.assertTrue("a", len(res["report"][0]["name"]))

jaseci/extens/api/tests/test_user_api.py

@@ -1,32 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class UserApiTest(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_user_create_global_init(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-        self.call(
-            self.smast,
-            ["global_sentinel_set", {}],
-        )
-        ret = self.call(
-            self.mast,
-            [
-                "user_create",
-                {
-                    "name": "joe",
-                    "global_init": "init",
-                    "global_init_ctx": {"wrld": "jason"},
-                },
-            ],
-        )
-        self.assertEqual(
-            ret["global_init"]["auto_run_result"]["report"], ["hello jason!"]
-        )
-        self.assertEqual(ret["user"]["name"], "joe")