msfabricpysdkcore 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

msfabricpysdkcore/tests/test_graphqlapi.py

@@ -1,44 +0,0 @@
-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_graphql_api(self):
-
-        fc = self.fc
-        workspace_id = '46425c13-5736-4285-972c-6d034020f3ff'
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-
-        graph_ql = fc.create_graphql_api(workspace_id, display_name="graphql" + datetime_str)
-        self.assertEqual(graph_ql.display_name, "graphql" + datetime_str)
-
-        graph_qls = fc.list_graphql_apis(workspace_id)
-        graph_ql_names = [gql.display_name for gql in graph_qls]
-        self.assertGreater(len(graph_qls), 0)
-        self.assertIn("graphql" + datetime_str, graph_ql_names)
-
-        gql = fc.get_graphql_api(workspace_id, graphql_api_name="graphql" + datetime_str)
-        self.assertIsNotNone(gql.id)
-        self.assertEqual(gql.display_name, "graphql" + datetime_str)
-
-        gql2 = fc.update_graphql_api(workspace_id, gql.id, display_name=f"graphql{datetime_str}2", return_item=True)
-
-        gql = fc.get_graphql_api(workspace_id, graphql_api_id=gql.id)
-        self.assertEqual(gql.display_name, f"graphql{datetime_str}2")
-
-        status_code = fc.delete_graphql_api(workspace_id, gql.id)
-        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_items.py

@@ -1,97 +0,0 @@
-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()
-        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        self.item_name = "testitem" + datetime_str
-        self.item_type = "Notebook"
-    
-    def test_item_end_to_end(self):
-
-        item = self.fc.create_item(display_name=self.item_name, type=self.item_type, workspace_id=self.workspace_id) 
-        self.assertEqual(item.display_name, self.item_name)
-        self.assertEqual(item.type, self.item_type)
-        self.assertEqual(item.workspace_id, self.workspace_id)
-        self.assertEqual(item.description, "")
-
-        item = self.fc.get_item(workspace_id=self.workspace_id, item_id=item.id)
-        item_ = self.fc.get_item(workspace_id=self.workspace_id,
-                                  item_name=self.item_name, item_type=self.item_type)
-        self.assertEqual(item.id, item_.id)
-        self.assertEqual(item.display_name, self.item_name)
-        self.assertEqual(item.type, self.item_type)
-        self.assertEqual(item.workspace_id, self.workspace_id)
-        self.assertEqual(item.description, "")
-
-        item_list = self.fc.list_items(workspace_id=self.workspace_id)
-        self.assertTrue(len(item_list) > 0)
-
-        item_ids = [item_.id for item_ in item_list]
-        self.assertIn(item.id, item_ids)
-
-        self.fc.update_item(workspace_id=self.workspace_id, item_id=item.id, display_name=f"u{self.item_name}", return_item=True)
-        item = self.fc.get_item(workspace_id=self.workspace_id, item_id=item.id)
-        self.assertEqual(item.display_name, f"u{self.item_name}")
-
-        status_code = self.fc.delete_item(workspace_id=self.workspace_id, item_id=item.id)
-
-        self.assertAlmostEqual(status_code, 200)
-
-    def test_item_definition(self):
-
-        sjd = self.fc.get_item(workspace_id=self.workspace_id, item_name="helloworld", item_type="SparkJobDefinition")
-        self.assertIsNotNone(sjd.definition)
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        blubb2 = "blubb2" + datetime_str
-        blubb3 = "blubb3" + datetime_str
-        blubb2 = self.fc.create_item(display_name=blubb2, type="SparkJobDefinition", workspace_id=self.workspace_id,
-                                   definition=sjd.definition)
-
-        blubb3 =  self.fc.create_item(display_name=blubb3, type="SparkJobDefinition", workspace_id=self.workspace_id)
-
-        response = self.fc.update_item_definition(workspace_id=self.workspace_id,
-                                                item_id=blubb3.id, definition=sjd.definition)
-        
-        self.assertEqual(response.status_code, 200)
-        blubb3 = self.fc.get_item(workspace_id=self.workspace_id, item_id=blubb3.id)
-
-        self.assertIn("parts", blubb3.definition)
-
-        self.assertEqual(len(blubb3.definition["parts"]), len(sjd.definition["parts"]))
-        sjd_defintion = [part["path"] for part in sjd.definition["parts"] if part["path"] == "SparkJobDefinitionV1.json"]
-        blubb3_defintion = [part["path"] for part in blubb3.definition["parts"] if part["path"] == "SparkJobDefinitionV1.json"]
-        self.assertEqual(sjd_defintion, blubb3_defintion)
-        
-        self.assertNotEqual(blubb2.id, sjd.id)
-        self.assertIn("parts", blubb2.definition)
-
-        self.assertEqual(len(blubb2.definition["parts"]), len(sjd.definition["parts"]))
-        sjd_defintion = [part["path"] for part in sjd.definition["parts"] if part["path"] == "SparkJobDefinitionV1.json"]
-        blubb2_defintion = [part["path"] for part in blubb2.definition["parts"] if part["path"] == "SparkJobDefinitionV1.json"]
-        self.assertEqual(sjd_defintion, blubb2_defintion)
-        self.assertNotEqual(blubb2.id, blubb3.id)
-        
-        blubb2.delete()
-        blubb3.delete()
-
-    def test_item_connections(self):
-
-        fc = self.fc
-        connections = fc.list_item_connections(workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3', item_id = '1bcc8b76-8e1f-428d-a594-f91ce1b9b076')
-        self.assertEqual(len(connections), 0)
-
-if __name__ == "__main__":
-    unittest.main()

msfabricpysdkcore/tests/test_jobs.py

@@ -1,96 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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)