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

msfabricpysdkcore/tests/test_external_data_shares.py

@@ -0,0 +1,51 @@
+import unittest
+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_external_data_shares(self):
+        
+        fc = self.fc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "82c01e0c-4cee-4a62-9806-870699ced699"
+
+        recipient = {
+            "userPrincipalName": "lisa4@fabrikam.com"
+        }
+        paths=["Files/to_share"]
+
+        resp = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
+        self.assertIsNotNone(resp)
+        self.assertIn('id', resp)
+
+
+        get = fc.get_external_data_share(workspace_id, item_id, resp['id'])
+        self.assertIsNotNone(get)
+        self.assertEqual(get['id'], resp['id'])
+
+
+        resp = fc.list_external_data_shares_in_item(workspace_id, item_id)
+        self.assertGreater(len(resp), 0)
+
+        data_share_ids = [ds['id'] for ds in resp]
+        self.assertIn(get['id'], data_share_ids)
+
+
+        resp = fc.revoke_external_data_share(workspace_id, item_id, get['id'])
+        self.assertEqual(resp, 200)
+
+        get2 = fc.get_external_data_share(workspace_id, item_id, get['id'])
+        self.assertIsNotNone(get2)
+        
+        self.assertEqual(get['id'], get2['id'])
+        self.assertEqual(get2['status'], 'Revoked')
+
+

msfabricpysdkcore/tests/test_fabric_azure_client.py

@@ -0,0 +1,80 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from time import sleep
+from msfabricpysdkcore import FabricAzureClient
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fac = FabricAzureClient()
+
+    def test_azure_capacity(self):
+
+        fac = self.fac
+
+        subscription_id = "c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8"
+        resource_group_name = "fabricdemo"
+        capacity_name = "westeuropeajrederer"
+        capacity_name_new = "westeuropeajrederer" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        resp = fac.check_name_availability(subscription_id, "westeurope", capacity_name_new)
+        self.assertIn('nameAvailable', resp)
+        self.assertEqual(resp['nameAvailable'], True)
+
+        resp = fac.create_or_update_capacity(subscription_id, resource_group_name, capacity_name_new, 
+                                            location="westeurope",
+                                            properties_administration={"members": ['admin@MngEnvMCAP065039.onmicrosoft.com']},
+                                            sku = "F2")
+        self.assertIsNotNone(resp.name)
+        self.assertEqual(resp.name, capacity_name_new)
+        
+        resp = fac.get_capacity(subscription_id, resource_group_name, capacity_name_new)
+        self.assertIsNotNone(resp.name)
+        self.assertEqual(resp.name, capacity_name_new)
+
+        sku = resp.sku['name']
+
+        sleep(60)
+        
+        resp = fac.delete_capacity(subscription_id, resource_group_name, capacity_name_new)
+        self.assertEqual(resp.status_code, 202)
+
+
+        resp = fac.list_by_resource_group(subscription_id, resource_group_name)
+        cap_names = [cap["name"] for cap in resp]
+        self.assertIn(capacity_name, cap_names)
+
+        
+
+        resp = fac.list_by_subscription(subscription_id)
+        cap_names = [cap["name"] for cap in resp]
+        self.assertIn(capacity_name, cap_names)
+
+
+        resp = fac.list_skus(subscription_id)
+        self.assertGreater(len(resp), 0, msg=f"No SKUs found: {resp}")
+
+
+        resp = fac.list_skus_for_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertGreater(len(resp), 0, msg=f"No SKUs found: {resp}")
+
+        resp = fac.resume_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertEqual(resp.status_code, 202)
+
+        sleep(60)
+        resp = fac.suspend_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertEqual(resp.status_code, 202)
+        sleep(180)
+
+        if sku != "F4":
+            resp = fac.update_capacity(subscription_id, resource_group_name, capacity_name, sku="F4")
+            self.assertEqual(resp.sku["name"], "F4")
+        else:
+            resp = fac.update_capacity(subscription_id, resource_group_name, capacity_name, sku="F2")
+            self.assertEqual(resp.sku["name"], "F2")

msfabricpysdkcore/tests/test_folders.py

@@ -0,0 +1,56 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_folders(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        folder_id = "d4f3a9fb-6975-4f5c-9c6b-ca205280966f"
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        display_name = f"sdk_folder_{datetime_str}"
+
+        folder = fcc.create_folder(workspace_id=workspace_id, display_name=display_name, parent_folder_id=folder_id)
+        self.assertIsNotNone(folder)
+        self.assertEqual(folder.display_name, display_name)
+
+        folder_ = fcc.get_folder(workspace_id=workspace_id, folder_id=folder.id)
+        self.assertEqual(folder.id, folder_.id)
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+        folders = [folder for folder in folders if folder.display_name == display_name]
+        self.assertGreater(len(folders), 0)
+
+        folder = fcc.update_folder(workspace_id=workspace_id, folder_id=folder.id, display_name=f"sdk_sub_folder_updated_{datetime_str}")
+        self.assertEqual(folder.display_name, f"sdk_sub_folder_updated_{datetime_str}")
+
+        folder = fcc.move_folder(workspace_id=workspace_id, folder_id=folder.id)
+        self.assertEqual(folder.display_name, f"sdk_sub_folder_updated_{datetime_str}")
+        self.assertEqual(folder.parent_folder_id, "")
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+
+        for f in folders:
+            if f.display_name != "sdk_folder":
+                f.delete()
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+        self.assertEqual(len(folders), 1)
+
+
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_gateways.py

@@ -0,0 +1,99 @@
+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_gateways(self):
+
+        fc = self.fc
+
+        gateways = fc.list_gateways()
+
+        for gw in gateways:
+            if "publicKey" not in gw:
+                fc.delete_gateway(gw['id'])
+            if "publicKey" in gw:
+                gw_id = gw['id']
+
+        datetime_str = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+        display_name = 'fabricvnet-' + datetime_str
+        gwr =  {'displayName': display_name,
+                'capacityId': '9e7e757d-d567-4fb3-bc4f-d230aabf2a00',
+                'virtualNetworkAzureResource': {'virtualNetworkName': 'fabricvnet',
+                'subnetName': 'default2',
+                'resourceGroupName': 'fabricdemo',
+                'subscriptionId': 'c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8'},
+                'inactivityMinutesBeforeSleep': 30,
+                'numberOfMemberGateways': 2,
+                'type': 'VirtualNetwork'}
+
+        gw = fc.create_gateway(gwr)
+        self.assertEqual(gw['displayName'], gwr['displayName'])
+
+        gateways = fc.list_gateways()
+        self.assertEqual(len(gateways), 2)
+
+        gateways = [g for g in gateways if g['displayName'] == display_name]
+        gw = gateways[0]
+
+        ras = fc.list_gateway_role_assignments(gw['id'])
+        self.assertEqual(len(ras), 1)
+
+        principal = {"id" : "755f273c-98f8-408c-a886-691794938bd8",
+                "type" : "ServicePrincipal"}
+
+        new_ras = fc.add_gateway_role_assignment(gw['id'], principal, 'ConnectionCreator')
+        self.assertIn("id", new_ras)
+        #self.assertEqual(2, len(fc.list_gateway_role_assignments(gw['id'])))
+
+        new_ras = fc.update_gateway_role_assignment(gw['id'], new_ras['id'], 'Admin')
+        self.assertEqual('Admin', new_ras['role'])
+
+        new_ras_ = fc.get_gateway_role_assignment(gw['id'], new_ras['id'])
+        self.assertEqual('Admin', new_ras_['role'])
+        self.assertEqual(new_ras['id'], new_ras_['id'])
+
+        resp_code = fc.delete_gateway_role_assignment(gw['id'], new_ras['id'])
+        self.assertEqual(200, resp_code)
+        self.assertEqual(1, len(fc.list_gateway_role_assignments(gw['id'])))
+
+        
+
+        gw_members = fc.list_gateway_members(gw_id)
+        self.assertGreater(len(gw_members), 0)
+        self.assertIn('id', gw_members[0])
+        self.assertIn('displayName', gw_members[0])
+
+        display_name_member = "surface_desktop" + datetime_str
+
+        gw_member = fc.update_gateway_member(gateway_id = gw_id, gateway_member_id = gw_id, display_name=display_name_member, enabled=True)
+        self.assertEqual(display_name_member, gw_member['displayName'])
+
+        gw_ = fc.get_gateway(gw["id"])
+        self.assertEqual(display_name, gw_['displayName'])
+
+        gwr = {
+            "type": "OnPremises",
+            "displayName": display_name,
+            "loadBalancingSetting": "Failover",
+            "allowCloudConnectionRefresh": False,
+            "allowCustomConnectors": False
+            }
+
+        gw_ = fc.update_gateway(gw_id, gwr)
+        self.assertEqual(display_name, gw_['displayName'])
+
+        resp_code = fc.delete_gateway(gw["id"])
+        self.assertEqual(200, resp_code)
+
+        self.assertEqual(len(fc.list_gateways()), 1)

msfabricpysdkcore/tests/test_git.py

@@ -0,0 +1,66 @@
+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()
+        
+    def test_git(self):
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        ws2_name = "git" + datetime_str
+        self.fc.create_workspace(display_name=ws2_name)
+        ws2 = self.fc.get_workspace_by_name(name=ws2_name)
+        self.fc.assign_to_capacity(workspace_id=ws2.id, capacity_id="9e7e757d-d567-4fb3-bc4f-d230aabf2a00")
+
+        git_provider_details = {'organizationName': 'MngEnvMCAP065039',
+                                'projectName': 'fabricdevops',
+                                'gitProviderType': 'AzureDevOps',
+                                'repositoryName': 'fabricdevops',
+                                'branchName': 'main',
+                                'directoryName': '/sdkdemoRTI'}
+
+        status_code = self.fc.git_connect(workspace_id=ws2.id, git_provider_details=git_provider_details)
+
+        self.assertEqual(status_code, 200)
+
+        initialization_strategy = "PreferWorkspace"
+
+        status_code = self.fc.git_initialize_connection(workspace_id=ws2.id, initialization_strategy=initialization_strategy)
+        self.assertEqual(status_code, 200)
+
+        connection_details = self.fc.git_get_connection(workspace_id=ws2.id)
+        self.assertEqual(connection_details['gitConnectionState'], 'ConnectedAndInitialized')
+
+        status = self.fc.git_get_status(workspace_id=ws2.id)
+        self.assertTrue(len(status["changes"]) > 0)
+
+        git_credentials = self.fc.get_my_git_credentials('e624ffea-990e-482c-b27c-4ed5adae73c6')
+        self.assertTrue(git_credentials["source"] == "Automatic")
+
+        status_code = self.fc.update_from_git(workspace_id=ws2.id, remote_commit_hash=status["remoteCommitHash"])
+
+        self.assertEqual(status_code, 202)
+
+        blubb_lakehouse = False
+        for item in ws2.list_items():
+            if item.type == "Lakehouse" and item.display_name == "blubb":
+                blubb_lakehouse = True
+
+        self.assertTrue(blubb_lakehouse)
+
+        status_code = self.fc.git_disconnect(workspace_id=ws2.id)
+
+        self.assertEqual(status_code, 200)
+
+        ws2.delete()
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_graphqlapi.py

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

@@ -0,0 +1,97 @@
+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 = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+
+
+        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 = '05bc5baa-ef02-4a31-ab20-158a478151d3', item_id = '82c01e0c-4cee-4a62-9806-870699ced699')
+        self.assertEqual(len(connections), 0)
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_jobs.py

@@ -0,0 +1,98 @@
+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 = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+        self.item_id = "9a2edf0f-2318-4179-80d0-1002f3dae7b1"
+
+
+    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
+
+
+        workspace_id = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+
+        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)
+
+        item_id = spark_job_definition.id
+
+        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 = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+
+        kql_dash = fc.get_kql_dashboard(workspace_id, kql_dashboard_name='dashboard1')
+        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('dashboard1', 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)
+