msfabricpysdkcore 0.0.13__py3-none-any.whl → 0.1.2__py3-none-any.whl

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -32,7 +32,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(pipe.display_name, 'sdkpipe')
         self.assertEqual(pipe.id, pipe_id)
 
-        stages = fc.get_deployment_pipeline_stages(pipe_id)
+        stages = fc.list_deployment_pipeline_stages(pipe_id)
 
         self.assertGreater(len(stages), 0)
         names = [stage.display_name for stage in stages]
@@ -42,12 +42,12 @@ class TestFabricClientCore(unittest.TestCase):
         dev_stage = [stage for stage in stages if stage.display_name == "Development"][0]
         prod_stage = [stage for stage in stages if stage.display_name == "Production"][0]
 
-        items = fc.get_deployment_pipeline_stages_items(pipeline_id=pipe_id, stage_id=dev_stage.id)
+        items = fc.list_deployment_pipeline_stages_items(deployment_pipeline_id=pipe_id, stage_id=dev_stage.id)
         
         self.assertGreater(len(items), 0)
         self.assertIn("cicdlakehouse", [item["itemDisplayName"] for item in items])
        
-        items = [item for item in dev_stage.get_items() if item["itemDisplayName"] == 'cicdlakehouse']
+        items = [item for item in dev_stage.list_items() if item["itemDisplayName"] == 'cicdlakehouse']
         item = items[0]
         item = {"sourceItemId": item["itemId"],
                 "itemType": item["itemType"]}

msfabricpysdkcore/tests/test_domains.py

@@ -1,5 +1,6 @@
 import unittest
 from dotenv import load_dotenv
+from datetime import datetime
 from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
 
 
@@ -17,7 +18,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         ws = fcc.get_workspace_by_name("sdktestdomains")
         cap = fcc.get_capacity(capacity_id=ws.capacity_id)
-        principal = {'id': 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2',  'type': 'User'}
+        principal = {'id': '1dc64c6e-7a10-4ea9-8488-85d0739a377d',  'type': 'User'}
 
         # Delete if exists
         try:
@@ -32,7 +33,7 @@ class TestFabricClientCore(unittest.TestCase):
             pass
 
         # Create domain
-        domain_name = "sdktestdomains"
+        domain_name = "sdktestdomains" + datetime.now().strftime("%Y%m%d%H%M%S")
         domain = fca.create_domain(display_name=domain_name)
         self.assertIsNotNone(domain.id)
         self.assertEqual(domain.display_name, domain_name)
@@ -54,8 +55,8 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIn(domain.id, domains_ids)
 
         # Update domain
-        domain_new_name = "sdktestdomains2"
-        domain_clone = fca.update_domain(domain.id, display_name=domain_new_name)
+        domain_new_name = f"{domain_name}2"
+        domain_clone = fca.update_domain(domain.id, display_name=domain_new_name, return_item=True)
         self.assertEqual(domain_clone.display_name, domain_new_name)
 
         # Assign domain workspaces by Ids
@@ -103,7 +104,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Role assignments bulk assign
         
-        principal_2 = {'id': '6edbc444-16cd-43f4-ae48-cbe734b89657', 'type': 'User'}
+        principal_2 = {'id': 'e0505016-ef55-4ca7-b106-e085cc201823', 'type': 'User'}
         principals = [principal, principal_2]
 
         status_code = fca.role_assignments_bulk_assign(domain.id, "Contributors", principals)

msfabricpysdkcore/tests/test_environments.py

@@ -14,7 +14,7 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environments_crudl(self):
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
 
         env_name = "env" + datetime_str
@@ -30,7 +30,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIsNotNone(env.id)
         self.assertEqual(env.display_name, env_name)
         new_name = env_name + "2"
-        env2 = fc.update_environment(workspace_id, env.id, display_name=new_name)
+        env2 = fc.update_environment(workspace_id, env.id, display_name=new_name, return_item=True)
 
         env = fc.get_environment(workspace_id, environment_id=env.id)
         self.assertEqual(env.display_name, new_name)
@@ -41,8 +41,8 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environment_details(self):
         fc = FabricClientCore()
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-        environment_id = 'fae6d1a7-d671-4091-89b1-f42626deb56f'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
         published_settings = fc.get_published_settings(workspace_id=workspace_id, environment_id=environment_id)
         self.assertIsNotNone(published_settings)
         self.assertIn("instancePool", published_settings)
@@ -62,4 +62,53 @@ class TestFabricClientCore(unittest.TestCase):
         updated_settings = fc.get_staging_settings(workspace_id=workspace_id, environment_id=environment_id)
         self.assertIn("instancePool", updated_settings)
         self.assertIn("dynamicExecutorAllocation", updated_settings)
-        self.assertEqual(updated_settings["driverCores"], driver_cores)
+        self.assertEqual(updated_settings["driverCores"], driver_cores)
+
+
+    def test_environment_spark_libraries(self):
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
+
+        resp = fc.get_published_libraries(workspace_id, environment_id)
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertIn('msfabricpysdkcore-0.1.1-py3-none-any.whl', resp['customLibraries']['wheelFiles'])
+
+        resp = fc.upload_staging_library(workspace_id, environment_id, 'dummy.whl')
+        self.assertEqual(resp.status_code, 200)
+        
+        resp = fc.get_staging_libraries(workspace_id, environment_id)
+
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertIn('dummy.whl', resp['customLibraries']['wheelFiles'])
+        self.assertIn('staging.whl', resp['customLibraries']['wheelFiles'])
+
+        
+        resp = fc.publish_environment(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'], 'running')
+
+        
+        resp = fc.cancel_publish(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'], 'cancelled')
+
+        resp = fc.delete_staging_library(workspace_id, environment_id, 'dummy.whl')
+        self.assertEqual(resp.status_code, 200)
+
+        resp = fc.get_staging_libraries(workspace_id, environment_id)
+
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertNotIn('dummy.whl', resp['customLibraries']['wheelFiles'])
+        self.assertIn('staging.whl', resp['customLibraries']['wheelFiles'])
+
+
+        
+
+
+

msfabricpysdkcore/tests/test_evenhouses.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_eventhouses(self):
+            
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        eventhouse_name = "evh" + datetime_str
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name=eventhouse_name)
+        self.assertEqual(eventhouse1.display_name, eventhouse_name)
+        
+        eventhouses = fc.list_eventhouses(workspace_id)
+        eventhouse_names = [eh.display_name for eh in eventhouses]
+        self.assertGreater(len(eventhouses), 0)
+        self.assertIn(eventhouse_name, eventhouse_names)
+
+        eh = fc.get_eventhouse(workspace_id, eventhouse_name=eventhouse_name)
+        self.assertIsNotNone(eh.id)
+        self.assertEqual(eh.display_name, eventhouse_name)
+        new_display_name = eventhouse_name + "2"
+        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name=new_display_name, return_item=True)
+
+        eh = fc.get_eventhouse(workspace_id, eventhouse_id=eh.id)
+        self.assertEqual(eh.display_name, new_display_name)
+        self.assertEqual(eh.id, eh2.id)
+
+        status_code = fc.delete_eventhouse(workspace_id, eh.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_evenstreams.py

@@ -15,30 +15,30 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_eventstreams(self):
 
-            fc = self.fc
-            workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
 
-            datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-            es_name = "es" + datetime_str
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        es_name = "es" + datetime_str
 
-            eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
-            self.assertEqual(eventstream.display_name, es_name)
+        eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
+        self.assertEqual(eventstream.display_name, es_name)
 
-            eventstreams = fc.list_eventstreams(workspace_id)
-            eventstream_names = [es.display_name for es in eventstreams]
-            self.assertGreater(len(eventstreams), 0)
-            self.assertIn(es_name, eventstream_names)
+        eventstreams = fc.list_eventstreams(workspace_id)
+        eventstream_names = [es.display_name for es in eventstreams]
+        self.assertGreater(len(eventstreams), 0)
+        self.assertIn(es_name, eventstream_names)
 
-            
-            es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
-            self.assertIsNotNone(es.id)
-            self.assertEqual(es.display_name, es_name)
+        
+        es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
+        self.assertIsNotNone(es.id)
+        self.assertEqual(es.display_name, es_name)
 
-            es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2")
+        es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2", return_item=True)
 
-            es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
-            self.assertEqual(es.display_name, f"{es_name}2")
-            self.assertEqual(es.id, es2.id)
+        es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
+        self.assertEqual(es.display_name, f"{es_name}2")
+        self.assertEqual(es.id, es2.id)
 
-            status_code = fc.delete_eventstream(workspace_id, es.id)
-            self.assertEqual(status_code, 200)
+        status_code = fc.delete_eventstream(workspace_id, es.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_external_data_shares.py

@@ -14,13 +14,13 @@ class TestFabricClientCore(unittest.TestCase):
         
         fc = self.fc
 
-        workspace_id = 'c3352d34-0b54-40f0-b204-cc964b1beb8d'
-        item_id = 'e2c09c89-bf97-4f71-bdeb-36338795ec36'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        item_id = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
 
         recipient = {
             "userPrincipalName": "lisa4@fabrikam.com"
         }
-        paths=["Files/external"]
+        paths=["Files/to_share"]
 
         resp = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
         self.assertIsNotNone(resp)

msfabricpysdkcore/tests/test_fabric_azure_client.py

@@ -0,0 +1,78 @@
+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']
+        
+        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(30)
+        resp = fac.suspend_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertEqual(resp.status_code, 202)
+        sleep(30)
+
+        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_git.py

@@ -11,7 +11,6 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = "fd3ba978-0b94-43e2-9f23-f65761e9ff34"
         
     def test_git(self):
 
@@ -19,14 +18,14 @@ class TestFabricClientCore(unittest.TestCase):
         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="a089a991-221c-49be-a41e-9020198cf7af")
-
-        git_provider_details = {'organizationName': 'dasenf1860',
-                        'projectName': 'fabrictest',
-                        'gitProviderType': 'AzureDevOps',
-                        'repositoryName': 'fabrictest',
-                        'branchName': 'main',
-                        'directoryName': '/folder1'}
+        self.fc.assign_to_capacity(workspace_id=ws2.id, capacity_id="840a6c1e-5289-4094-bbc8-716daabaeeba")
+
+        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)
 

msfabricpysdkcore/tests/test_items.py

@@ -0,0 +1,81 @@
+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.assertEqual(blubb3.definition, sjd.definition)
+        
+        self.assertNotEqual(blubb2.id, sjd.id)
+        self.assertEqual(blubb2.definition, sjd.definition)
+        self.assertNotEqual(blubb2.id, blubb3.id)
+        
+        blubb2.delete()
+        blubb3.delete()
+
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_jobs.py

@@ -11,8 +11,8 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
-        self.item_id = "7e38f344-81df-4805-83b6-b9cc16830500"
+        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        self.item_id = "38a1c15f-8a9e-49c5-8d05-a27cf9ce8b18"
 
 
     def test_jobs_end_to_end(self):

msfabricpysdkcore/tests/test_kql_queryset.py

@@ -0,0 +1,49 @@
+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 = "kqlqueryset1"
+
+        kql_querysets = fc.list_kql_querysets(workspace_id)
+        kql_queryset_names = [kqlq.display_name for kqlq in kql_querysets]
+        self.assertGreater(len(kql_querysets), 0)
+        self.assertIn(kql_queryset_name, kql_queryset_names)
+
+        kqlq = fc.get_kql_queryset(workspace_id, kql_queryset_name=kql_queryset_name)
+        self.assertIsNotNone(kqlq.id)
+        self.assertEqual(kqlq.display_name, kql_queryset_name)
+
+        kqlq2 = fc.update_kql_queryset(workspace_id, kqlq.id, display_name=f"{kql_queryset_name}2", return_item=True)
+
+        kqlq = fc.get_kql_queryset(workspace_id, kql_queryset_id=kqlq.id)
+        self.assertEqual(kqlq.display_name, f"{kql_queryset_name}2")
+        self.assertEqual(kqlq.id, kqlq2.id)
+
+        kqlq2 = fc.update_kql_queryset(workspace_id, kqlq.id, display_name=kql_queryset_name, return_item=True)
+
+        kqlq = fc.get_kql_queryset(workspace_id, kql_queryset_id=kqlq.id)
+        self.assertEqual(kqlq.display_name, kql_queryset_name)
+        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

@@ -16,8 +16,8 @@ class TestFabricClientCore(unittest.TestCase):
     def test_kql_database(self):
 
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-        evenhouse_id = "14822d45-5460-4efa-9b30-8628510a9197"
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        evenhouse_id = "f30ba76a-92c3-40d3-ad69-36db059c113d"
 
         creation_payload = {"databaseType" : "ReadWrite",
                             "parentEventhouseItemId" : evenhouse_id}
@@ -38,7 +38,7 @@ class TestFabricClientCore(unittest.TestCase):
         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)
+        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)

msfabricpysdkcore/tests/test_lakehouse.py

@@ -0,0 +1,84 @@
+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):
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        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)