msfabricpysdkcore 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

msfabricpysdkcore/tests/test_kqldatabases.py

@@ -0,0 +1,48 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+    
+    def test_kql_database(self):
+
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        evenhouse_id = "14822d45-5460-4efa-9b30-8628510a9197"
+
+        creation_payload = {"databaseType" : "ReadWrite",
+                            "parentEventhouseItemId" : evenhouse_id}
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        kqldb_name = "kql" + datetime_str
+        kqldb = fc.create_kql_database(workspace_id = workspace_id, display_name=kqldb_name,
+                                    creation_payload=creation_payload)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+
+        kql_databases = fc.list_kql_databases(workspace_id)
+        kql_database_names = [kqldb.display_name for kqldb in kql_databases]
+        self.assertGreater(len(kql_databases), 0)
+        self.assertIn(kqldb_name, kql_database_names)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_name=kqldb_name)
+        self.assertIsNotNone(kqldb.id)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+        
+        new_name = kqldb_name+"2"
+        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name=new_name)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
+        self.assertEqual(kqldb.display_name, new_name)
+        self.assertEqual(kqldb.id, kqldb2.id)
+        
+        status_code = fc.delete_kql_database(workspace_id, kqldb.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_shortcuts.py

@@ -1,7 +1,9 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
 from datetime import datetime
-#from dotenv import load_dotenv
+from dotenv import load_dotenv
+
+load_dotenv()
 
 class TestFabricClientCore(unittest.TestCase):
 

msfabricpysdkcore/tests/test_spark.py

@@ -0,0 +1,91 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        ws = self.fc.get_workspace_by_name(name="testitems")
+        self.workspace_id = ws.id
+
+
+    def test_spark_workspace_custom_pools(self):
+        fc = self.fc
+        workspace_id = self.workspace_id
+
+        # List 
+
+        pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
+        self.assertGreater(len(pools), 0)
+
+        pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
+
+        self.assertIn("pool1", [p.name for p in pools])
+        pool1 = [p for p in pools if p.name == "pool1"][0]
+
+        # Get
+
+        pool1_clone = fc.get_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool1.id)
+        self.assertEqual(pool1_clone.id, pool1.id)
+        # Create
+
+        pool2 = fc.create_workspace_custom_pool(workspace_id=workspace_id, 
+                                        name="pool2", 
+                                        node_family="MemoryOptimized",
+                                        node_size="Small", 
+                                        auto_scale = {"enabled": True, "minNodeCount": 1, "maxNodeCount": 2},
+                                        dynamic_executor_allocation = {"enabled": True, "minExecutors": 1, "maxExecutors": 1})
+
+        self.assertEqual(pool2.name, "pool2")
+        self.assertEqual(pool2.node_family, "MemoryOptimized")
+
+        # Update
+
+        pool2 = fc.update_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id,
+                                        auto_scale = {"enabled": True, "minNodeCount": 1, "maxNodeCount": 7})
+
+        self.assertEqual(pool2.auto_scale["maxNodeCount"], 7)
+        pool2_clone = fc.get_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id)
+        self.assertEqual(pool2_clone.auto_scale["maxNodeCount"], 7)
+
+        # Delete
+        status_code = fc.delete_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id)
+        self.assertEqual(status_code, 200)
+
+        pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
+        self.assertNotIn("pool2", [p.name for p in pools])
+
+    def test_workspace_settings(self):
+        fc = self.fc
+        workspace_id = self.workspace_id
+
+        # Get
+
+        settings = fc.get_spark_settings(workspace_id)
+        self.assertIn("automaticLog", settings)
+        
+        
+        orig_setting = settings["automaticLog"]["enabled"]
+        settings["automaticLog"]["enabled"] = not settings["automaticLog"]["enabled"]
+
+        # Update
+        settings = fc.update_spark_settings(workspace_id, automatic_log=settings["automaticLog"])
+        new_setting = settings["automaticLog"]["enabled"]
+        self.assertNotEqual(orig_setting, new_setting)
+        self.assertTrue(orig_setting or new_setting)
+        self.assertFalse(orig_setting and new_setting)
+
+        settings = fc.get_spark_settings(workspace_id)
+        checked_setting = settings["automaticLog"]["enabled"]
+        self.assertEqual(checked_setting, new_setting)
+
+
+if __name__ == "__main__":
+    unittest.main()
+

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -1,8 +1,9 @@
 import unittest
-#from dotenv import load_dotenv
+from dotenv import load_dotenv
 from datetime import datetime
 from msfabricpysdkcore.coreapi import FabricClientCore
 
+load_dotenv()
 
 class TestFabricClientCore(unittest.TestCase):
 
@@ -104,12 +105,12 @@ class TestFabricClientCore(unittest.TestCase):
 
 #    def test_update_workspace(self):
         ws_updated = self.fc.update_workspace(workspace_id=ws.id, 
-                                              display_name="newname8912389u1293", 
+                                              display_name="newn912389u8293", 
                                               description="new description")
-        self.assertEqual(ws_updated.display_name, "newname8912389u1293")
+        self.assertEqual(ws_updated.display_name, "newn912389u8293")
         self.assertEqual(ws_updated.description, "new description")
         ws = self.fc.get_workspace_by_id(id = ws.id)
-        self.assertEqual(ws.display_name, "newname8912389u1293")
+        self.assertEqual(ws.display_name, "newn912389u8293")
         self.assertEqual(ws.description, "new description")
 
 #    def test_unassign_from_capacity(self):
@@ -120,7 +121,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(ws.capacity_id, None)
 
 #    def test_delete_workspace(self):
-        result_status = self.fc.delete_workspace(display_name="newname8912389u1293")
+        result_status = self.fc.delete_workspace(display_name="newn912389u8293")
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):