msfabricpysdkcore 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

msfabricpysdkcore/tests/test_shortcuts.py

@@ -0,0 +1,60 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from datetime import datetime
+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()
+        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        self.lakehouse_target = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
+        self.lakehouse_shortcut = "9d1e8b07-2fea-4fc5-872c-fb586d085149"
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.shortcutname = "shortcut" + datetime_str
+        self.path_target = "Files/to_share"
+        self.path_shortcut = "Files/shortcutfolder"
+
+        self.target = {'oneLake': {'itemId': self.lakehouse_target,
+                                   'path': self.path_target,        
+                                   'workspaceId': self.workspace_id}}
+
+    def test_shortcut_end_to_end(self):
+
+        item = self.fc.create_shortcut(workspace_id=self.workspace_id,
+                                       item_id=self.lakehouse_shortcut,
+                                       path=self.path_shortcut,
+                                       name=self.shortcutname,
+                                       target=self.target)
+        self.assertEqual(item.name, self.shortcutname)
+        self.assertEqual(item.path, self.path_shortcut)
+        self.assertIn("oneLake", item.target)
+
+        item = self.fc.get_shortcut(workspace_id=self.workspace_id,
+                                    item_id=self.lakehouse_shortcut,
+                                    path=self.path_shortcut,
+                                    name=self.shortcutname)
+        self.assertEqual(item.name, self.shortcutname)
+        self.assertEqual(item.path, self.path_shortcut)
+        self.assertIn("oneLake", item.target)
+
+        shortcuts = self.fc.list_shortcuts(workspace_id=self.workspace_id,
+                                          item_id=self.lakehouse_shortcut, parent_path="Files")
+        self.assertGreater(len(shortcuts), 0)
+
+
+        status_code = self.fc.delete_shortcut(workspace_id=self.workspace_id,
+                                             item_id=self.lakehouse_shortcut,
+                                             path=self.path_shortcut,
+                                             name=self.shortcutname)
+        
+        self.assertAlmostEqual(status_code, 200)
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_spark.py

@@ -0,0 +1,91 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+from datetime import datetime
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+
+    def test_spark_workspace_custom_pools(self):
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        pool_name = "pool" + datetime.now().strftime("%Y%m%d%H%M%S")
+        # 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=pool_name, 
+                                        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, pool_name)
+        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},
+                                        return_item=True)
+
+        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(pool_name, [p.name for p in pools])
+
+    def test_workspace_settings(self):
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        # 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_sparkjobdefinition.py

@@ -0,0 +1,55 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+    def test_spark_job_definitions(self):
+        
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        spark_job_definition_name = f"sjd{datetime_str}"
+
+        spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
+
+        result = fc.run_on_demand_spark_job_definition(workspace_id=workspace_id, 
+                                                        spark_job_definition_id=spark_job_definition_w_content.id,
+                                                        job_type="sparkjob")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.job_type, "sparkjob")
+        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
+        spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
+        fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
+        spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)
+        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
+        self.assertIsNotNone(spark_job_definition.definition)
+
+        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
+        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
+        self.assertGreater(len(spark_job_definitions), 0)
+        self.assertIn(spark_job_definition_name, spark_job_definition_names)
+
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
+        self.assertIsNotNone(sjd.id)
+        self.assertEqual(sjd.display_name, spark_job_definition_name)
+
+        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2", return_item=True)
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
+        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
+
+        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_sqldatabases.py

@@ -0,0 +1,45 @@
+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):
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+   
+    def test_sql_databases(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        # datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        # sql_db = fc.create_sql_database(workspace_id, display_name="sqldb" + datetime_str)
+        # self.assertEqual(sql_db.display_name, "sqldb" + datetime_str)
+
+        # sql_dbs = fc.list_sql_databases(workspace_id)
+        # sql_db_names = [db.display_name for db in sql_dbs]
+        # self.assertGreater(len(sql_dbs), 0)
+        # self.assertIn("sqldb" + datetime_str, sql_db_names)
+
+        # db = fc.get_sql_database(workspace_id, sql_database_name="sqldb" + datetime_str)
+        # self.assertIsNotNone(db.id)
+        # self.assertEqual(db.display_name, "sqldb" + datetime_str)
+
+        # db2 = fc.update_sql_database(workspace_id, db.id, display_name=f"sqldb{datetime_str}2", return_item=True)
+
+        # db = fc.get_sql_database(workspace_id, sql_database_id=db.id)
+        # self.assertEqual(db.display_name, f"sqldb{datetime_str}2")
+
+        # status_code = fc.delete_sql_database(workspace_id, db.id)
+        # self.assertEqual(status_code, 200)
+        

msfabricpysdkcore/tests/test_warehouses.py

@@ -0,0 +1,50 @@
+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()
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+
+
+    def test_warehouses(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        warehouse1 = f"wh{datetime_str}"
+        warehouse = fc.create_warehouse(workspace_id, display_name=warehouse1)
+        self.assertIsNotNone(warehouse.id)
+
+        warehouses = fc.list_warehouses(workspace_id)
+        warehouse_names = [wh.display_name for wh in warehouses]
+        self.assertGreater(len(warehouses), 0)
+        self.assertIn(warehouse1, warehouse_names)
+
+        warehouse = fc.get_warehouse(workspace_id, warehouse_name=warehouse1)
+        self.assertIsNotNone(warehouse.id)
+        self.assertEqual(warehouse.display_name, warehouse1)
+
+        warehouse2 = fc.update_warehouse(workspace_id, warehouse.id, display_name=f"{warehouse1}2", return_item=True)
+        warehouse = fc.get_warehouse(workspace_id, warehouse_id=warehouse.id)
+        self.assertEqual(warehouse.display_name, f"{warehouse1}2")
+        self.assertEqual(warehouse.id, warehouse2.id)
+
+        status_code = fc.delete_warehouse(workspace_id, warehouse.id)
+        self.assertEqual(status_code, 200)
+
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -0,0 +1,159 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+    
+    def test_end_to_end_workspace(self):
+        fc = self.fc
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        display_name = "testws" + datetime_str
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        workspace_name_new = "newws" + datetime_str
+        ws_created = fc.create_workspace(display_name=display_name,
+                                              description="test workspace", 
+                                              exists_ok=False)
+        # Add assertions here to verify the result
+        self.assertEqual(ws_created.display_name, display_name)
+        workspace_id = ws_created.id
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(ws.display_name, display_name)
+        self.assertEqual(ws.description, "test workspace")
+
+#   def test_assign_to_capacity(self):
+        
+        result_status_code = fc.assign_to_capacity(workspace_id=ws.id, 
+                                                        capacity_id="840a6c1e-5289-4094-bbc8-716daabaeeba")
+        self.assertEqual(result_status_code, 202)
+      
+
+#    def test_list_workspaces(self):
+        
+        result = fc.list_workspaces()
+        display_names = [ws.display_name for ws in result]
+        self.assertIn(display_name, display_names)
+
+        for ws in result:
+            if ws.display_name == display_name:
+                self.assertEqual(ws.capacity_id, "840a6c1e-5289-4094-bbc8-716daabaeeba")
+
+
+  #  def test_get_workspace_by_name(self):
+
+        workspace_name = display_name
+        ws = fc.get_workspace_by_name(name = workspace_name)
+        self.assertEqual(ws.display_name, display_name)
+
+ #   def test_get_workspace_by_id(self):
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(display_name, ws.display_name)
+
+
+#    def test_get_workspace(self):
+        result = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(result.display_name, display_name)
+    
+ #   def test_add_role_assignment(self):
+        result_status = fc.add_workspace_role_assignment(workspace_id = ws.id,
+                                                         principal = {"id" : "755f273c-98f8-408c-a886-691794938bd8",
+                                                                        "type" : "ServicePrincipal"},
+                                                         role = 'Member')
+        
+        self.assertEqual(result_status, 201)
+
+ #   def test_get_workspace_role_assignments(self):
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
+            if user["principal"]["displayName"] == "fabrictestuser":
+                self.assertEqual(user["role"], "Member")
+
+        # Get get_workspace_role_assignment
+
+        result = fc.get_workspace_role_assignment(workspace_id = ws.id, 
+                                                  workspace_role_assignment_id = "755f273c-98f8-408c-a886-691794938bd8")
+        
+        self.assertEqual(result["role"], "Member")
+
+#    def test_update_workspace_role_assignment(self):
+
+        result_status_code = fc.update_workspace_role_assignment(workspace_id = ws.id, 
+                                                                      role = "Contributor", 
+                                                                      workspace_role_assignment_id= "755f273c-98f8-408c-a886-691794938bd8")
+        
+        self.assertEqual(result_status_code, 200)
+
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
+            if user["principal"]["displayName"] == "fabrictestuser":
+                self.assertTrue(user["role"] == "Contributor")
+
+#   def test_delete_role_assignment(self):
+        result_status_code = fc.delete_workspace_role_assignment(workspace_id = ws.id,
+                                                                 workspace_role_assignment_id = "755f273c-98f8-408c-a886-691794938bd8")
+        self.assertEqual(result_status_code, 200)
+
+ #   def test_get_workspace_role_assignments(self):
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 1)
+        user = result[0]
+#        self.assertTrue(user["principal"]["displayName"] == "fabricapi")
+        self.assertTrue(user["role"] == "Admin")
+
+#    def test_update_workspace(self):
+        ws_updated = fc.update_workspace(workspace_id=ws.id, 
+                                              display_name=workspace_name_new, 
+                                              description="new description")
+        self.assertEqual(ws_updated.display_name, workspace_name_new)
+        self.assertEqual(ws_updated.description, "new description")
+        ws = fc.get_workspace_by_id(id = ws.id)
+        self.assertEqual(ws.display_name, workspace_name_new)
+        self.assertEqual(ws.description, "new description")
+
+#    def test_unassign_from_capacity(self):
+
+        result_status_code = fc.unassign_from_capacity(workspace_id=ws.id)
+        self.assertEqual(result_status_code, 202)
+        ws = fc.get_workspace_by_id(ws.id)
+        self.assertEqual(ws.capacity_id, None)
+
+        # result = fc.provision_identity(workspace_id=ws.id)
+        # self.assertIsNotNone(result["applicationId"])
+        # fc.deprovision_identity(workspace_id=ws.id)
+
+
+
+#    def test_delete_workspace(self):
+        result_status = fc.delete_workspace(display_name=workspace_name_new)
+        self.assertEqual(result_status, 200)
+
+    def test_list_capacities(self):
+        result = self.fc.list_capacities()
+        self.assertTrue(len(result) > 0)
+        cap_ids = [cap.id for cap in result]
+        self.assertIn("c861242b-c4ac-4e3a-9a21-13f65d9b17b2", cap_ids)
+
+    def test_get_capacity(self):
+        capacity = self.fc.get_capacity(capacity_id = "c861242b-c4ac-4e3a-9a21-13f65d9b17b2")
+        self.assertEqual(capacity.id, "c861242b-c4ac-4e3a-9a21-13f65d9b17b2")
+
+        cap = self.fc.get_capacity(capacity_name= capacity.display_name)
+
+        self.assertEqual(capacity.id, cap.id)
+        self.assertIsNotNone(cap.state)
+        self.assertIsNotNone(cap.sku)
+        self.assertIsNotNone(cap.region)
+
+
+if __name__ == "__main__":
+    unittest.main()