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

msfabricpysdkcore/otheritems.py

@@ -1,5 +1,15 @@
 from msfabricpysdkcore.item import Item
 
+class ApacheAirflowJob(Item):
+    """Class to represent a ApacheAirflowJob in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return ApacheAirflowJob(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class CopyJob(Item):
     """Class to represent a copy job in Microsoft Fabric"""
@@ -36,7 +46,44 @@ class DataPipeline(Item):
         
     def run_on_demand_item_job(self, execution_data=None):
         return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id, job_type="Pipeline", execution_data=execution_data)
+
+class DigitalTwinBuilder(Item):
+    """Class to represent a DigitalTwinBuilder in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return DigitalTwinBuilder(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
+
+class DigitalTwinBuilderFlow(Item):
+    """Class to represent a DigitalTwinBuilderFlow in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return DigitalTwinBuilderFlow(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
+
+class MirroredAzureDatabricksCatalog(Item):
+    """Class to represent a mirrored Azure Databricks catalog in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return MirroredAzureDatabricksCatalog(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
+    def refresh_catalog_metadata(self):
+        """Method to refresh the metadata of the mirrored Azure Databricks catalog"""
+        return self.core_client.refresh_mirrored_azure_databricks_catalog_metadata(self.workspace_id, self.id)
+
 class Eventhouse(Item):
     """Class to represent a eventhouse in Microsoft Fabric"""
      
@@ -110,6 +157,17 @@ class Warehouse(Item):
         return Warehouse(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
+    
+class WarehouseSnapshot(Item):
+    """Class to represent a warehouse snapshot in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return WarehouseSnapshot(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class KQLDashboard(Item):
     """Class to represent a kql dashboard in Microsoft Fabric"""
@@ -180,7 +238,9 @@ class GraphQLApi(Item):
         return GraphQLApi(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
-    
+
+
+
 class MirroredDatabase(Item):
     """Class to represent a mirrored database in Microsoft Fabric"""
      

msfabricpysdkcore/tests/test_admin_apis.py

@@ -147,7 +147,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         fca = self.fca
 
-        items = [{"id": "9cdd3192-bcd0-4cbe-b945-29f5964e7ab7", "type": "Lakehouse"}]
+        items = [{"id": "e79d7a0e-1741-4ddf-a705-b861f2775f97", "type": "Lakehouse"}]
         label_id = "defa4170-0d19-0005-0007-bc88714345d2"
         resp = fca.bulk_set_labels(items=items, label_id=label_id)
         self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
@@ -159,7 +159,7 @@ class TestFabricClientCore(unittest.TestCase):
         fca = self.fca
 
         data_shares = fca.list_external_data_shares()
-        ws_id = "63aa9e13-4912-4abe-9156-8a56e565b7a3"
+        ws_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
 
         data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
 

msfabricpysdkcore/tests/test_apache_airflow_job.py

@@ -0,0 +1,60 @@
+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_apache_airflow_job(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "4e685286-d909-4ccb-911f-590ee3c3df14"
+
+        apache_airflow_job = fcc.list_apache_airflow_jobs(workspace_id=workspace_id)
+        for apache_airflow_job in apache_airflow_job:
+            if apache_airflow_job.id != item_id:
+                resp = fcc.delete_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job.id)
+                self.assertEqual(resp, 200)
+
+        apache_airflow_job_definition = fcc.get_apache_airflow_job_definition(workspace_id=workspace_id, apache_airflow_job_id=item_id)
+        self.assertIn("definition", apache_airflow_job_definition)
+        definition = apache_airflow_job_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"copyjob{date_str}"
+
+        apache_airflow_job_new = fcc.create_apache_airflow_job(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(apache_airflow_job_new.display_name, date_str)
+
+        apache_airflow_job_get = fcc.get_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id)
+        self.assertEqual(apache_airflow_job_get.display_name, date_str)
+
+        apache_airflow_job = fcc.list_apache_airflow_jobs(workspace_id=workspace_id)
+        self.assertEqual(len(apache_airflow_job), 2)
+
+        date_str_updated = date_str + "_updated"
+        apache_airflow_job_updated = fcc.update_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(apache_airflow_job_updated.display_name, date_str_updated)
+
+        apache_airflow_job_updated = fcc.update_apache_airflow_job_definition(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id, definition=definition)
+        self.assertEqual(apache_airflow_job_updated.status_code, 200)
+
+        for apache_airflow_job in apache_airflow_job:
+            if apache_airflow_job.id != item_id:
+                resp = fcc.delete_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_digital_twin_builder.py

@@ -0,0 +1,60 @@
+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_digital_twin_builder(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "d7260274-8038-44ec-b096-dec1723931d1"
+
+        digital_twin_builder = fcc.list_digital_twin_builders(workspace_id=workspace_id)
+        for digital_twin_builder in digital_twin_builder:
+            if digital_twin_builder.id != item_id:
+                resp = fcc.delete_digital_twin_builder(workspace_id=workspace_id, digital_twin_builder_id=digital_twin_builder.id)
+                self.assertEqual(resp, 200)
+
+        digital_twin_builder_definition = fcc.get_digital_twin_builder_definition(workspace_id=workspace_id, digital_twin_builder_id=item_id)
+        self.assertIn("definition", digital_twin_builder_definition)
+        definition = digital_twin_builder_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"copyjob{date_str}"
+
+        digital_twin_builder_new = fcc.create_digital_twin_builder(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(digital_twin_builder_new.display_name, date_str)
+
+        digital_twin_builder_get = fcc.get_digital_twin_builder(workspace_id=workspace_id, digital_twin_builder_id=digital_twin_builder_new.id)
+        self.assertEqual(digital_twin_builder_get.display_name, date_str)
+
+        digital_twin_builder = fcc.list_digital_twin_builders(workspace_id=workspace_id)
+        self.assertEqual(len(digital_twin_builder), 2)
+
+        date_str_updated = date_str + "_updated"
+        digital_twin_builder_updated = fcc.update_digital_twin_builder(workspace_id=workspace_id, digital_twin_builder_id=digital_twin_builder_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(digital_twin_builder_updated.display_name, date_str_updated)
+
+        digital_twin_builder_updated = fcc.update_digital_twin_builder_definition(workspace_id=workspace_id, digital_twin_builder_id=digital_twin_builder_new.id, definition=definition)
+        self.assertIn(digital_twin_builder_updated.status_code, [200,202])
+
+        for digital_twin_builder in digital_twin_builder:
+            if digital_twin_builder.id != item_id:
+                resp = fcc.delete_digital_twin_builder(workspace_id=workspace_id, digital_twin_builder_id=digital_twin_builder.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -16,21 +16,14 @@ class TestFabricClientCore(unittest.TestCase):
         fcc = FabricClientCore()
         fca = FabricClientAdmin()
 
-        ws = fcc.get_workspace_by_name("sdktestdomains")
+        ws = fcc.get_workspace_by_name("sdkswedencentral")
         cap = fcc.get_capacity(capacity_id=ws.capacity_id)
         principal = {'id': '1dc64c6e-7a10-4ea9-8488-85d0739a377d',  'type': 'User'}
 
         # Delete if exists
-        try:
-            domain = fca.get_domain_by_name("sdktestdomains")
-            domain.delete()
-        except:
-            pass
-        try:
-            domain = fca.get_domain_by_name("sdktestdomains2")
-            domain.delete()
-        except:
-            pass
+        for dom in fca.list_domains():
+            if "sdktestdomain" in dom.display_name:
+                dom.delete()
 
         # Create domain
         domain_name = "sdktestdomains" + datetime.now().strftime("%Y%m%d%H%M%S")
@@ -64,9 +57,9 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(status_code, 200)
 
         # List domain workspaces
-        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=False)
         self.assertGreater(len(workspaces), 0)
-        workspaces_ids = [w.id for w in workspaces]
+        workspaces_ids = [w["id"] for w in workspaces]
         self.assertIn(ws.id, workspaces_ids)
 
         # Unassign domain workspaces by ids
@@ -80,9 +73,9 @@ class TestFabricClientCore(unittest.TestCase):
         status_code = fca.assign_domain_workspaces_by_capacities(domain.id, [cap.id])
         self.assertEqual(status_code, 202)
 
-        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=False)
         self.assertGreater(len(workspaces), 0)
-        workspaces_ids = [w.id for w in workspaces]
+        workspaces_ids = [w["id"] for w in workspaces]
         self.assertIn(ws.id, workspaces_ids)
 
         # Unassign all domain workspaces
@@ -93,13 +86,13 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(len(workspaces), 0)
 
         # Assign domain workspaces by principals
-        status_code = fca.assign_domains_workspaces_by_principals(domain.id, [principal], wait_for_completion=True)
+        status_code = fca.assign_domains_workspaces_by_principals(domain.id, [principal], wait_for_completion=False)
 
         self.assertEqual(status_code, 202)
 
-        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=False)
         self.assertGreater(len(workspaces), 0)
-        workspaces_ids = [w.id for w in workspaces]
+        workspaces_ids = [w["id"] for w in workspaces]
         self.assertIn(ws.id, workspaces_ids)
 
         # Role assignments bulk assign

msfabricpysdkcore/tests/test_environments.py

@@ -13,36 +13,45 @@ class TestFabricClientCore(unittest.TestCase):
         self.fc = FabricClientCore()
 
     def test_environments_crudl(self):
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        fcc = self.fc
+        workspace_id = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+        item_id = '35a08bcb-ff8c-40f7-93ea-b86dc1affce5'
+
+        environments = fcc.list_environments(workspace_id=workspace_id)
+        for environment in environments:
+            if environment.id != item_id:
+                resp = fcc.delete_environment(workspace_id=workspace_id, environment_id=environment.id)
+                self.assertEqual(resp, 200)
+
 
-        env_name = "env" + datetime_str
-        environment1 = fc.create_environment(workspace_id, display_name=env_name)
-        self.assertEqual(environment1.display_name, env_name)
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"environment{date_str}"
 
-        environments = fc.list_environments(workspace_id)
-        environment_names = [env.display_name for env in environments]
-        self.assertGreater(len(environments), 0)
-        self.assertIn(env_name, environment_names)
+        environment_new = fcc.create_environment(workspace_id=workspace_id, display_name=date_str)
 
-        env = fc.get_environment(workspace_id, environment_name=env_name)
-        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, return_item=True)
+        self.assertEqual(environment_new.display_name, date_str)
 
-        env = fc.get_environment(workspace_id, environment_id=env.id)
-        self.assertEqual(env.display_name, new_name)
-        self.assertEqual(env.id, env2.id)
+        environment_get = fcc.get_environment(workspace_id=workspace_id, environment_id=environment_new.id)
+        self.assertEqual(environment_get.display_name, date_str)
 
-        status_code = fc.delete_environment(workspace_id, env.id)
-        self.assertEqual(status_code, 200)
+        environments = fcc.list_environments(workspace_id=workspace_id)
+        self.assertEqual(len(environments), 2)
+
+        date_str_updated = date_str + "_updated"
+        environment_updated = fcc.update_environment(workspace_id=workspace_id, environment_id=environment_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(environment_updated.display_name, date_str_updated)
+
+        for environment in environments:
+            if environment.id != item_id:
+                resp = fcc.delete_environment(workspace_id=workspace_id, environment_id=environment.id)
+                self.assertEqual(resp, 200)
 
     def test_environment_details(self):
         fc = FabricClientCore()
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
+        workspace_id = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+        environment_id = '35a08bcb-ff8c-40f7-93ea-b86dc1affce5'
+
         published_settings = fc.get_published_settings(workspace_id=workspace_id, environment_id=environment_id)
         self.assertIsNotNone(published_settings)
         self.assertIn("instancePool", published_settings)
@@ -67,13 +76,13 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environment_spark_libraries(self):
         fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
+        workspace_id = '05bc5baa-ef02-4a31-ab20-158a478151d3'
+        environment_id = '35a08bcb-ff8c-40f7-93ea-b86dc1affce5'
 
         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'])
+        self.assertIn('msfabricpysdkcore-0.2.6-py3-none-any.whl', resp['customLibraries']['wheelFiles'])
 
         resp = fc.upload_staging_library(workspace_id, environment_id, 'dummy.whl')
         self.assertEqual(resp.status_code, 200)
@@ -83,7 +92,6 @@ class TestFabricClientCore(unittest.TestCase):
         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)
@@ -105,7 +113,6 @@ class TestFabricClientCore(unittest.TestCase):
         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_evenstreams.py

@@ -15,38 +15,43 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_eventstreams(self):
 
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        fcc = self.fc
 
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        es_name = "es" + datetime_str
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "94f4b54b-980b-43f9-8b67-ded8028cf1b9"
 
-        eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
-        self.assertEqual(eventstream.display_name, es_name)
+        eventstreams = fcc.list_eventstreams(workspace_id=workspace_id)
+        for eventstream in eventstreams:
+            if eventstream.id != item_id:
+                resp = fcc.delete_eventstream(workspace_id=workspace_id, eventstream_id=eventstream.id)
+                self.assertEqual(resp, 200)
 
-        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)
+        eventstream_definition = fcc.get_eventstream_definition(workspace_id=workspace_id, eventstream_id=item_id)
+        self.assertIn("definition", eventstream_definition)
+        definition = eventstream_definition["definition"]
 
-        
-        es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
-        self.assertIsNotNone(es.id)
-        self.assertEqual(es.display_name, es_name)
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"eventstream{date_str}"
 
-        es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2", return_item=True)
+        eventstream_new = fcc.create_eventstream(workspace_id=workspace_id, display_name=date_str, definition=definition)
 
-        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)
+        self.assertEqual(eventstream_new.display_name, date_str)
 
-        response = fc.update_eventstream_definition(workspace_id, eventstream_id=es.id, definition=es.definition)
-        self.assertIn(response.status_code, [200, 202])
+        eventstream_get = fcc.get_eventstream(workspace_id=workspace_id, eventstream_id=eventstream_new.id)
+        self.assertEqual(eventstream_get.display_name, date_str)
 
-        definition = fc.get_eventstream_definition(workspace_id, eventstream_id=es.id)
-        self.assertIn("definition", definition)
-        self.assertIn("parts", definition["definition"])
-        self.assertGreaterEqual(len(definition["definition"]["parts"]), 3)
+        eventstreams = fcc.list_eventstreams(workspace_id=workspace_id)
+        self.assertEqual(len(eventstreams), 2)
 
-        status_code = fc.delete_eventstream(workspace_id, es.id)
-        self.assertEqual(status_code, 200)
+        date_str_updated = date_str + "_updated"
+        eventstream_updated = fcc.update_eventstream(workspace_id=workspace_id, eventstream_id=eventstream_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(eventstream_updated.display_name, date_str_updated)
+
+        eventstream_updated = fcc.update_eventstream_definition(workspace_id=workspace_id, eventstream_id=eventstream_new.id, definition=definition)
+        self.assertEqual(eventstream_updated.status_code, 200)
+
+        for eventstream in eventstreams:
+            if eventstream.id != item_id:
+                resp = fcc.delete_eventstream(workspace_id=workspace_id, eventstream_id=eventstream.id)
+                self.assertEqual(resp, 200)

msfabricpysdkcore/tests/test_eventhouses.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()
+
+        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):
+            
+        fcc = self.fc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "5d544ac1-c58d-4d3a-a032-f57dc4b5c2a7"
+
+        eventhouses = fcc.list_eventhouses(workspace_id=workspace_id)
+        for eventhouse in eventhouses:
+            if eventhouse.id != item_id:
+                resp = fcc.delete_eventhouse(workspace_id=workspace_id, eventhouse_id=eventhouse.id)
+                self.assertEqual(resp, 200)
+
+        eventhouse_definition = fcc.get_eventhouse_definition(workspace_id=workspace_id, eventhouse_id=item_id)
+        self.assertIn("definition", eventhouse_definition)
+        definition = eventhouse_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"eventhouse{date_str}"
+
+        eventhouse_new = fcc.create_eventhouse(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(eventhouse_new.display_name, date_str)
+
+        eventhouse_get = fcc.get_eventhouse(workspace_id=workspace_id, eventhouse_id=eventhouse_new.id)
+        self.assertEqual(eventhouse_get.display_name, date_str)
+
+        eventhouses = fcc.list_eventhouses(workspace_id=workspace_id)
+        self.assertEqual(len(eventhouses), 2)
+
+        date_str_updated = date_str + "_updated"
+        eventhouse_updated = fcc.update_eventhouse(workspace_id=workspace_id, eventhouse_id=eventhouse_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(eventhouse_updated.display_name, date_str_updated)
+
+        eventhouse_updated = fcc.update_eventhouse_definition(workspace_id=workspace_id, eventhouse_id=eventhouse_new.id, definition=definition)
+        self.assertIn(eventhouse_updated.status_code, [200, 202])
+
+        for eventhouse in eventhouses:
+            if eventhouse.id != item_id:
+                resp = fcc.delete_eventhouse(workspace_id=workspace_id, eventhouse_id=eventhouse.id)
+                self.assertEqual(resp, 200)

msfabricpysdkcore/tests/test_external_data_shares.py

@@ -14,8 +14,8 @@ class TestFabricClientCore(unittest.TestCase):
         
         fc = self.fc
 
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-        item_id = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "82c01e0c-4cee-4a62-9806-870699ced699"
 
         recipient = {
             "userPrincipalName": "lisa4@fabrikam.com"

msfabricpysdkcore/tests/test_fabric_azure_client.py

@@ -70,7 +70,7 @@ class TestFabricClientCore(unittest.TestCase):
         sleep(60)
         resp = fac.suspend_capacity(subscription_id, resource_group_name, capacity_name)
         self.assertEqual(resp.status_code, 202)
-        sleep(60)
+        sleep(180)
 
         if sku != "F4":
             resp = fac.update_capacity(subscription_id, resource_group_name, capacity_name, sku="F4")

msfabricpysdkcore/tests/test_folders.py

@@ -1,6 +1,7 @@
 import unittest
 from dotenv import load_dotenv
 from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
 
 load_dotenv()
 
@@ -15,23 +16,25 @@ class TestFabricClientCore(unittest.TestCase):
 
         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="sdk_sub_folder", parent_folder_id=folder_id)
+        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, "sdk_sub_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 == "sdk_sub_folder"]
+        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="sdk_sub_folder_updated")
-        self.assertEqual(folder.display_name, "sdk_sub_folder_updated")
+        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, "sdk_sub_folder_updated")
+        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)

msfabricpysdkcore/tests/test_gateways.py

@@ -28,9 +28,9 @@ class TestFabricClientCore(unittest.TestCase):
         datetime_str = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
         display_name = 'fabricvnet-' + datetime_str
         gwr =  {'displayName': display_name,
-                'capacityId': '339c785f-4489-46ae-a649-e049e7610479',
+                'capacityId': '9e7e757d-d567-4fb3-bc4f-d230aabf2a00',
                 'virtualNetworkAzureResource': {'virtualNetworkName': 'fabricvnet',
-                'subnetName': 'default3',
+                'subnetName': 'default2',
                 'resourceGroupName': 'fabricdemo',
                 'subscriptionId': 'c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8'},
                 'inactivityMinutesBeforeSleep': 30,
@@ -54,7 +54,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         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'])))
+        #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'])

msfabricpysdkcore/tests/test_git.py

@@ -18,7 +18,7 @@ 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="840a6c1e-5289-4094-bbc8-716daabaeeba")
+        self.fc.assign_to_capacity(workspace_id=ws2.id, capacity_id="9e7e757d-d567-4fb3-bc4f-d230aabf2a00")
 
         git_provider_details = {'organizationName': 'MngEnvMCAP065039',
                                 'projectName': 'fabricdevops',

msfabricpysdkcore/tests/test_items.py

@@ -12,7 +12,7 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        self.workspace_id = '05bc5baa-ef02-4a31-ab20-158a478151d3'
 
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -90,7 +90,7 @@ class TestFabricClientCore(unittest.TestCase):
     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')
+        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__":