msfabricpysdkcore 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

msfabricpysdkcore/tests/test_jobs.py

@@ -0,0 +1,96 @@
+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.item_id = "38a1c15f-8a9e-49c5-8d05-a27cf9ce8b18"
+
+
+    def test_jobs_end_to_end(self):
+        job = self.fc.run_on_demand_item_job(workspace_id=self.workspace_id,
+                                            item_id=self.item_id,
+                                            job_type="RunNotebook")
+        
+        self.assertEqual(job.item_id, self.item_id)
+        self.assertEqual(job.workspace_id, self.workspace_id)
+        self.assertEqual(job.job_type, "RunNotebook")
+        self.assertIn(job.status, ["NotStarted", "InProgress", "Failed"])
+        self.assertEqual(job.invoke_type, "Manual")
+
+        job2 = self.fc.get_item_job_instance(workspace_id=self.workspace_id,
+                                        item_id=self.item_id,
+                                        job_instance_id=job.id)
+        
+        self.assertEqual(job.id, job2.id)
+
+        status_code = self.fc.cancel_item_job_instance(workspace_id=self.workspace_id,
+                                                  item_id=self.item_id,
+                                                  job_instance_id=job.id)
+
+        self.assertEqual(status_code, 202)
+
+        job_instances = self.fc.list_item_job_instances(workspace_id=self.workspace_id,
+                                                        item_id=self.item_id)
+        
+        self.assertGreaterEqual(len(job_instances), 1)
+
+    def test_item_schedules(self):
+
+        fc = self.fc
+
+        item_id = "42b6e090-24ff-4dc7-8c52-cdae0ddd2c06"
+
+        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")
+        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, definition=definition)
+
+        self.assertIsNotNone(spark_job_definition)
+
+        configuration = {'type': 'Daily',
+                         'startDateTime': '2024-11-21T00:00:00',
+                         'endDateTime': '2028-11-08T23:59:00',
+                         'localTimeZoneId': 'Romance Standard Time',
+                         'times': ['15:39']}
+
+        schedule = spark_job_definition.create_item_schedule(job_type="sparkjob", configuration=configuration, enabled=True)
+
+        schedule_id = schedule["id"]
+        schedule_check = spark_job_definition.get_item_schedule(schedule_id=schedule_id, job_type="sparkjob")
+        self.assertIsNotNone(schedule_check)
+        self.assertEqual(schedule_check["id"], schedule_id)
+
+        schedule_new = spark_job_definition.update_item_schedule(schedule_id=schedule_id, job_type="sparkjob", configuration=configuration, enabled=False)
+        self.assertIsNotNone(schedule_new)
+
+        schedule_check = spark_job_definition.get_item_schedule(schedule_id=schedule_id, job_type="sparkjob")
+        self.assertEqual(schedule_check["id"], schedule_id)
+        self.assertFalse(schedule_check["enabled"])
+        list_schedules = fc.list_item_schedules(workspace_id, item_id, job_type="sparkjob")
+
+        self.assertGreater(len(list_schedules), 0)
+
+        spark_job_definition.delete()
+
+if __name__ == "__main__":
+    unittest.main()
+

msfabricpysdkcore/tests/test_kql_dashboards.py

@@ -0,0 +1,63 @@
+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_dashboards(self):
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        kql_dash = fc.get_kql_dashboard(workspace_id, kql_dashboard_name='sampledashboard')
+        kql_dash_orig_id = kql_dash.id
+
+
+        kql_dash_name = "testdash" + datetime_str
+
+        kql_dash = fc.create_kql_dashboard(display_name=kql_dash_name, workspace_id=workspace_id)
+        self.assertEqual(kql_dash.display_name, kql_dash_name)
+
+        definition_orig = fc.get_kql_dashboard_definition(workspace_id, kql_dash_orig_id)
+        definition_orig = definition_orig["definition"]
+        self.assertIsNotNone(definition_orig)
+
+        definition = fc.update_kql_dashboard_definition(workspace_id, kql_dash.id, definition=definition_orig)
+
+        self.assertIsNotNone(definition)
+
+        kql_dashs = fc.list_kql_dashboards(workspace_id)
+
+        kql_dash_names = [kqld.display_name for kqld in kql_dashs]
+        self.assertGreater(len(kql_dashs), 0)
+        self.assertIn(kql_dash_name, kql_dash_names)
+        self.assertIn('sampledashboard', kql_dash_names)
+
+        kql_dash2 = fc.get_kql_dashboard(workspace_id, kql_dashboard_name=kql_dash_name)
+        self.assertIsNotNone(kql_dash2.id)
+        self.assertEqual(kql_dash2.display_name, kql_dash_name)
+
+        new_name = kql_dash_name+"2"
+        kql_dash3 = fc.update_kql_dashboard(workspace_id, kql_dash.id, display_name=new_name, return_item=True)
+
+        self.assertEqual(kql_dash3.display_name, new_name)
+        self.assertEqual(kql_dash.id, kql_dash3.id)
+
+        resp_code = fc.delete_kql_dashboard(workspace_id, kql_dash3.id)
+        self.assertEqual(resp_code, 200)
+
+        kql_dashs = fc.list_kql_dashboards(workspace_id)
+
+        kql_dash_names = [kqld.display_name for kqld in kql_dashs]
+        self.assertNotIn(kql_dash3.display_name, kql_dash_names)
+

msfabricpysdkcore/tests/test_kql_queryset.py

@@ -0,0 +1,64 @@
+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_kql_querysets(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        kql_queryset_name = "kqlqueryset12"
+        kqlq_w_content = fc.get_kql_queryset(workspace_id, kql_queryset_name=kql_queryset_name)
+
+        definition = fc.get_kql_queryset_definition(workspace_id, kqlq_w_content.id)
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
+        self.assertIsNotNone(kqlq_w_content.id)
+        self.assertEqual(kqlq_w_content.display_name, kql_queryset_name)
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        kql_queryset_new = "kqlq" + datetime_str
+
+        kqlq = fc.create_kql_queryset(workspace_id, definition=definition, display_name=kql_queryset_new)
+        self.assertIsNotNone(kqlq.id)
+        self.assertEqual(kqlq.display_name, kql_queryset_new)
+
+        fc.update_kql_queryset_definition(workspace_id, kqlq.id, definition=definition)
+        kqlq = fc.get_kql_queryset(workspace_id, kqlq.id)
+        self.assertEqual(kqlq.display_name, kql_queryset_new)
+        self.assertIsNotNone(kqlq.definition)
+
+        kqlqs = fc.list_kql_querysets(workspace_id)
+        kqlq_names = [kql.display_name for kql in kqlqs]
+        self.assertGreater(len(kqlqs), 0)
+        self.assertIn(kql_queryset_new, kqlq_names)
+
+        kqlq = fc.get_kql_queryset(workspace_id, kql_queryset_name=kql_queryset_new)
+        self.assertIsNotNone(kqlq.id)
+        self.assertEqual(kqlq.display_name, kql_queryset_new)
+
+        kqlq2 = fc.update_kql_queryset(workspace_id, kql_queryset_id=kqlq.id, display_name=f"{kql_queryset_new}2", return_item=True)
+
+        kqlq = fc.get_kql_queryset(workspace_id, kql_queryset_id=kqlq.id)
+        self.assertEqual(kqlq.display_name, f"{kql_queryset_new}2")
+        self.assertEqual(kqlq.id, kqlq2.id)
+
+        status_code = fc.delete_kql_queryset(workspace_id, kqlq.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_kqldatabases.py

@@ -0,0 +1,56 @@
+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 = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        evenhouse_id = "f30ba76a-92c3-40d3-ad69-36db059c113d"
+
+        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, return_item=True)
+
+        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)
+        
+        response = fc.update_kql_database_definition(workspace_id, kqldb.id, kqldb.definition)
+        self.assertIn(response.status_code, [200, 202])
+
+        definition = fc.get_kql_database_definition(workspace_id, kql_database_id=kqldb.id)
+        self.assertIn("definition", definition)
+        self.assertIn("parts", definition["definition"])
+        self.assertGreaterEqual(len(definition["definition"]["parts"]), 3)
+
+        status_code = fc.delete_kql_database(workspace_id, kqldb.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_lakehouse.py

@@ -0,0 +1,93 @@
+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_lakehouse(self):
+
+        lakehouse2 = "lh2" + datetime.now().strftime("%Y%m%d%H%M%S")
+        lakehouse3 = "lh3" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        lhs = self.fc.list_lakehouses(workspace_id = workspace_id, with_properties=True)
+        lh = [lh_ for lh_ in lhs if lh_.display_name == "lakelhousewlabels"][0]
+        tables = lh.list_tables()
+        table_names = [t["name"] for t in tables]
+        self.assertIn("titanic2", table_names)
+
+        lakehouse = self.fc.get_item(workspace_id=workspace_id, item_name="lakelhousewlabels", item_type="Lakehouse")
+        self.assertIsNotNone(lakehouse.properties)
+        lakehouse_id = lakehouse.id
+        date_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        table_name = f"table{date_str}"
+
+
+        status_code = self.fc.load_table(workspace_id=workspace_id, lakehouse_id=lakehouse_id, table_name=table_name, 
+                                         path_type="File", relative_path="Files/to_share/titanic2.csv")
+
+        self.assertEqual(status_code, 202)
+
+        # Run on demand table maintenance
+        table_name_maintenance = "table20240515114529"
+
+        execution_data = {
+            "tableName": table_name_maintenance,
+            "optimizeSettings": {
+            "vOrder": True,
+            "zOrderBy": [
+                "tipAmount"
+            ]
+            },
+            "vacuumSettings": {
+            "retentionPeriod": "7:01:00:00"
+            }
+        }
+        
+        response = self.fc.run_on_demand_table_maintenance(workspace_id=workspace_id, lakehouse_id=lakehouse_id, 
+                                                           execution_data = execution_data,
+                                                           job_type = "TableMaintenance", wait_for_completion = False)
+        self.assertIn(response.status_code, [200, 202])
+
+        table_list = self.fc.list_tables(workspace_id=workspace_id, lakehouse_id=lakehouse_id)
+        table_names = [table["name"] for table in table_list]
+
+        self.assertIn(table_name, table_names)
+
+        fc = self.fc
+
+        lakehouse = fc.create_lakehouse(workspace_id=workspace_id, display_name=lakehouse2)
+        self.assertIsNotNone(lakehouse.id)
+
+        lakehouses = fc.list_lakehouses(workspace_id)
+        lakehouse_names = [lh.display_name for lh in lakehouses]
+        self.assertGreater(len(lakehouse_names), 0)
+        self.assertIn(lakehouse2, lakehouse_names)
+
+        lakehouse2 = fc.get_lakehouse(workspace_id=workspace_id, lakehouse_id=lakehouse.id)
+        self.assertEqual(lakehouse.id, lakehouse2.id)
+
+        sleep(20)
+        lakehouse2 = fc.update_lakehouse(workspace_id=workspace_id, lakehouse_id=lakehouse.id, display_name=lakehouse3, return_item=True)
+        self.assertEqual(lakehouse2.display_name, lakehouse3)
+
+        id = lakehouse2.id
+
+        lakehouse2 = fc.get_lakehouse(workspace_id=workspace_id, lakehouse_name=lakehouse3)
+        self.assertEqual(lakehouse2.id, id)
+
+        status_code = fc.delete_lakehouse(workspace_id=workspace_id, lakehouse_id=lakehouse.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_managed_private_endpoints.py

@@ -0,0 +1,61 @@
+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_workspace_managed_private_endpoints(self):
+                    
+        fc = self.fc
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        mpes = fc.list_workspace_managed_private_endpoints(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb')
+
+        if len(mpes) > 0:
+
+            for mpe in mpes:
+                status_code = fc.delete_workspace_managed_private_endpoint(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb',
+                                                                        managed_private_endpoint_id=mpe["id"])
+                self.assertEqual(status_code, 200)
+            sleep(60)
+
+        mpe = fc.create_workspace_managed_private_endpoint(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb',
+                                                           name = f'testmpe{datetime_str}',
+                                                           target_private_link_resource_id = '/subscriptions/c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8/resourceGroups/fabricdemo/providers/Microsoft.Storage/storageAccounts/publicfabricdemo9039',
+                                                           target_subresource_type = 'dfs',
+                                                           request_message = 'testmessage')
+        
+        mpes = fc.list_workspace_managed_private_endpoints(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb')
+
+        self.assertIsNotNone(mpes)
+        self.assertGreater(len(mpes), 0)
+
+        mpe2 = fc.get_workspace_managed_private_endpoint(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb', 
+                                                         managed_private_endpoint_id=mpe["id"])
+
+        self.assertEqual(mpe2["id"], mpe["id"])
+
+        self.assertIsNotNone(mpe2["connectionState"])
+        self.assertIn("targetPrivateLinkResourceId", mpe2)
+        self.assertEqual(mpe2["targetPrivateLinkResourceId"], "/subscriptions/c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8/resourceGroups/fabricdemo/providers/Microsoft.Storage/storageAccounts/publicfabricdemo9039")
+
+        for _ in range(0, 20):
+            if mpe2["connectionState"]["status"] != "Pending":
+                sleep(30)
+            else:
+                status_code = fc.delete_workspace_managed_private_endpoint(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb',
+                                                                           managed_private_endpoint_id=mpe["id"])
+                self.assertEqual(status_code, 200)
+                break
+            mpe2 = fc.get_workspace_managed_private_endpoint(workspace_id='535910f6-abe1-499d-94ad-f698c28805fb',
+                                                             managed_private_endpoint_id=mpe["id"])
+

msfabricpysdkcore/tests/test_mirroreddatabases.py

@@ -0,0 +1,80 @@
+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_mirrored_database(self):
+
+        fc = self.fc
+        workspace_id = '46425c13-5736-4285-972c-6d034020f3ff'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        mirrored_db_name = "mirrored_db" + datetime_str
+
+        # mirrored_db_w_content = fc.get_mirrored_database(workspace_id, mirrored_database_name="dfsdemo")
+
+        # status = fc.get_mirroring_status(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+        # self.assertIsNotNone(status)
+        # self.assertIn("status", status)
+
+        # status = status["status"]
+
+        # if status == 'Running':
+        #     fc.stop_mirroring(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+        #     sleep(60)
+        #     fc.start_mirroring(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+        # else:
+        #     fc.start_mirroring(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+        #     sleep(60)
+        #     fc.stop_mirroring(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+
+        # table_status = fc.get_tables_mirroring_status(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+
+        # self.assertIsNotNone(table_status)
+        # self.assertIn("data", table_status)
+        # for _ in range(5):
+        #     if len(table_status["data"]) > 0:
+        #         break
+        #     sleep(60)
+        #     table_status = fc.get_tables_mirroring_status(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+        # self.assertIn("sourceTableName", table_status["data"][0])
+
+        # fc.stop_mirroring(workspace_id=workspace_id, mirrored_database_id=mirrored_db_w_content.id)
+
+        # definition = fc.get_mirrored_database_definition(workspace_id, mirrored_db_w_content.id)
+        # self.assertIsNotNone(definition)
+        # self.assertIn("definition", definition)
+        # self.assertIn("parts", definition["definition"])
+
+        # mirrored_db = fc.create_mirrored_database(workspace_id, display_name=mirrored_db_name)
+        
+        # mirrored_db_check = fc.get_mirrored_database(workspace_id, mirrored_database_id=mirrored_db.id)
+        # self.assertEqual(mirrored_db_check.display_name, mirrored_db_name)
+        # self.assertIsNotNone(mirrored_db_check.id)
+        # self.assertEqual(mirrored_db_check.id, mirrored_db_check.id)
+
+        # mirrored_dbs = fc.list_mirrored_databases(workspace_id)
+        # mirrored_db_names = [md.display_name for md in mirrored_dbs]
+        # self.assertGreater(len(mirrored_dbs), 0)
+        # self.assertIn(mirrored_db_name, mirrored_db_names)
+
+        # sleep(60)
+
+        # mirrored_db_2 = fc.update_mirrored_database(workspace_id, mirrored_db_check.id,
+        #                                             display_name=f"u{mirrored_db_name}", return_item=True)
+        # mirrored_db_2 = fc.get_mirrored_database(workspace_id, mirrored_database_id=mirrored_db_2.id)
+
+        # self.assertEqual(mirrored_db_2.display_name, f"u{mirrored_db_name}")
+
+        # status_code = fc.delete_mirrored_database(workspace_id, mirrored_db_2.id)
+        # self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_ml_experiments.py

@@ -0,0 +1,47 @@
+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_ml_experiments(self):
+            
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        mlexperiment_name = "mlexp" + datetime.now().strftime("%Y%m%d%H%M%S")
+        mlexperiment_name2 = "mlexp2" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        ml_experiment = fc.create_ml_experiment(workspace_id, display_name=mlexperiment_name)
+        self.assertEqual(ml_experiment.display_name, mlexperiment_name)
+        
+        ml_experiments = fc.list_ml_experiments(workspace_id)
+        ml_experiment_names = [mle.display_name for mle in ml_experiments]
+        self.assertGreater(len(ml_experiments), 0)
+        self.assertIn(mlexperiment_name, ml_experiment_names)
+
+        mle = fc.get_ml_experiment(workspace_id, ml_experiment_name=mlexperiment_name)
+        self.assertIsNotNone(mle.id)
+        self.assertEqual(mle.display_name, mlexperiment_name)
+
+        mle2 = fc.update_ml_experiment(workspace_id, mle.id, display_name=mlexperiment_name2, return_item=True)
+
+        mle = fc.get_ml_experiment(workspace_id, ml_experiment_id=mle.id)
+        self.assertEqual(mle.display_name, mlexperiment_name2)
+        self.assertEqual(mle.id, mle2.id)
+
+        status_code = fc.delete_ml_experiment(workspace_id, mle.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_ml_models.py

@@ -0,0 +1,47 @@
+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_ml_models(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        model_name = "mlm" + datetime_str
+
+        ml_model = fc.create_ml_model(workspace_id, display_name=model_name)
+        self.assertEqual(ml_model.display_name, model_name)
+        
+        ml_models = fc.list_ml_models(workspace_id)
+        ml_model_names = [ml.display_name for ml in ml_models]
+        self.assertGreater(len(ml_models), 0)
+        self.assertIn(model_name, ml_model_names)
+
+        mlm = fc.get_ml_model(workspace_id, ml_model_name=model_name)
+        self.assertIsNotNone(mlm.id)
+        self.assertEqual(mlm.display_name, model_name)
+
+        mlm2 = fc.update_ml_model(workspace_id=workspace_id,ml_model_id= mlm.id,  description=model_name, return_item=True)
+
+        mlm = fc.get_ml_model(workspace_id, ml_model_id=mlm.id)
+        self.assertEqual(mlm.description, model_name)
+        self.assertEqual(mlm.id, mlm2.id)
+
+        status_code = fc.delete_ml_model(workspace_id, mlm.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_mounted_adf.py

@@ -0,0 +1,64 @@
+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_mounted_adf(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        definition = {'parts': [{'path': 'mountedDataFactory-content.json',
+                                'payload': 'ewogICJkYXRhRmFjdG9yeVJlc291cmNlSWQiOiAiL3N1YnNjcmlwdGlvbnMvYzc3Y2M4ZmMtNDNiYi00ZDQ0LWJkYzUtNmUyMDUxMWVkMmE4L3Jlc291cmNlR3JvdXBzL2ZhYnJpY2RlbW8vcHJvdmlkZXJzL01pY3Jvc29mdC5EYXRhRmFjdG9yeS9mYWN0b3JpZXMvZmFicmljYWRmMjAyNTAzMDYiCn0=',
+                                'payloadType': 'InlineBase64'},
+                                {'path': '.platform',
+                                'payload': 'ewogICIkc2NoZW1hIjogImh0dHBzOi8vZGV2ZWxvcGVyLm1pY3Jvc29mdC5jb20vanNvbi1zY2hlbWFzL2ZhYnJpYy9naXRJbnRlZ3JhdGlvbi9wbGF0Zm9ybVByb3BlcnRpZXMvMi4wLjAvc2NoZW1hLmpzb24iLAogICJtZXRhZGF0YSI6IHsKICAgICJ0eXBlIjogIk1vdW50ZWREYXRhRmFjdG9yeSIsCiAgICAiZGlzcGxheU5hbWUiOiAiZmFicmljYWRmMjAyNTAzMDYiCiAgfSwKICAiY29uZmlnIjogewogICAgInZlcnNpb24iOiAiMi4wIiwKICAgICJsb2dpY2FsSWQiOiAiMDAwMDAwMDAtMDAwMC0wMDAwLTAwMDAtMDAwMDAwMDAwMDAwIgogIH0KfQ==',
+                                'payloadType': 'InlineBase64'}]}
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        mounted_adf_name = "mounted_adf" + datetime_str
+        mounted_adf = fc.create_mounted_data_factory(workspace_id,
+                                                     display_name=mounted_adf_name,
+                                                     definition=definition)
+
+        self.assertEqual(mounted_adf.display_name, mounted_adf_name)
+
+        mounted_adfs = fc.list_mounted_data_factories(workspace_id)
+        mounted_adf_names = [adf.display_name for adf in mounted_adfs]
+        self.assertGreater(len(mounted_adfs), 0)
+        self.assertIn(mounted_adf_name, mounted_adf_names)
+
+        adf = fc.get_mounted_data_factory(workspace_id, mounted_data_factory_name=mounted_adf_name)
+        self.assertIsNotNone(adf.id)
+        self.assertEqual(adf.display_name, mounted_adf_name)
+
+        adf2 = fc.update_mounted_data_factory(workspace_id, adf.id, display_name=f"{mounted_adf_name}2", return_item=True)
+
+        adf = fc.get_mounted_data_factory(workspace_id, mounted_data_factory_id=adf.id)
+        self.assertEqual(adf.display_name, f"{mounted_adf_name}2")
+        self.assertEqual(adf.id, adf2.id)
+
+        response = fc.update_mounted_data_factory_definition(workspace_id, mounted_data_factory_id=adf.id, definition=adf.definition)
+        self.assertIn(response.status_code, [200, 202])
+
+        definition = fc.get_mounted_data_factory_definition(workspace_id, mounted_data_factory_id=adf.id)
+        self.assertIn("definition", definition)
+        self.assertIn("parts", definition["definition"])
+        self.assertGreaterEqual(len(definition["definition"]["parts"]), 2)
+
+        status_code = fc.delete_mounted_data_factory(workspace_id, adf.id)
+        self.assertEqual(status_code, 200)