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

msfabricpysdkcore/tests/test_deployment_pipelinev2.py

@@ -0,0 +1,135 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from datetime import datetime
+from dotenv import load_dotenv
+import time
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        
+    def test_deployment_pipeline2(self):
+        fcc = self.fc
+        workspace_id = "72d9d955-bd1e-42c7-9746-208f7cbc8956"
+
+        user_id = "e0505016-ef55-4ca7-b106-e085cc201823"
+        capacity_id = "9e7e757d-d567-4fb3-bc4f-d230aabf2a00"
+
+        prod_workspace = fcc.create_workspace("sdkswedenproddeploy")
+        prod_workspace.assign_to_capacity(capacity_id)
+
+        stages =  [
+            {
+            "displayName": "Development",
+            "description": "Development stage description",
+            "isPublic": False
+            },
+            {
+            "displayName": "Production",
+            "description": "Production stage description",
+            "isPublic":True
+            }
+        ]
+
+        pipes = fcc.list_deployment_pipelines(with_details=False)
+        for pipe in pipes:
+            if "sdk" in pipe["displayName"]:
+                fcc.delete_deployment_pipeline(deployment_pipeline_id=pipe["id"])
+        
+        pipe =fcc.create_deployment_pipeline(display_name="sdktestpipeline",
+                              description="Test Deployment Pipeline Description",
+                              stages=stages)
+        
+        self.assertIsNotNone(pipe.id)
+        pipe_id = pipe.id
+
+        for stage in pipe.stages:
+            if stage["displayName"] == "Development":
+                dev_stage = stage
+            else:
+                prod_stage = stage
+        
+        stage = fcc.get_deployment_pipeline_stage(deployment_pipeline_id=pipe_id,
+                                                  stage_id=dev_stage["id"])
+        self.assertIsNotNone(stage.id)
+        resp = fcc.assign_workspace_to_stage(deployment_pipeline_id=pipe_id,
+                              stage_id=dev_stage["id"],
+                              workspace_id=workspace_id)
+        self.assertEqual(resp, 200)
+
+        resp = fcc.assign_workspace_to_stage(deployment_pipeline_id=pipe_id,
+                              stage_id=prod_stage["id"],
+                              workspace_id=prod_workspace.id)
+        self.assertEqual(resp, 200)
+        principal = {
+            "id": user_id,
+            "type": "User"
+        }
+
+        resp = fcc.add_deployment_pipeline_role_assignment(deployment_pipeline_id=pipe_id,principal=principal, role="Admin")
+        self.assertEqual(resp, 200)
+
+        roles = fcc.list_deployment_pipeline_role_assignments(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(roles) == 2)
+
+        resp = fcc.delete_deployment_pipeline_role_assignment(deployment_pipeline_id=pipe_id, principal_id=user_id)
+        self.assertEqual(resp, 200)
+
+        roles = fcc.list_deployment_pipeline_role_assignments(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(roles) == 1)
+
+        pipes = fcc.list_deployment_pipelines(with_details=False)
+        sdk_pipes = [pipe for pipe in pipes  if "sdk" in pipe["displayName"]]
+        self.assertTrue(len(sdk_pipes) > 0)
+
+        resp = fcc.deploy_stage_content(deployment_pipeline_id=pipe_id,
+                        source_stage_id=dev_stage["id"],
+                        target_stage_id=prod_stage["id"], wait_for_completion=False)
+        self.assertEqual(resp.status_code, 202)
+
+        ops = fcc.list_deployment_pipeline_operations(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(ops) > 0)
+
+        ops = fcc.get_deployment_pipeline_operation(deployment_pipeline_id=pipe_id, operation_id=ops[0]["id"])
+        self.assertIsNotNone(ops["id"])
+
+        stages = fcc.list_deployment_pipeline_stages(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(stages) == 2)
+
+        items = fcc.list_deployment_pipeline_stage_items(deployment_pipeline_id=pipe_id, stage_id=dev_stage["id"])
+        self.assertTrue(len(items) == 1)
+
+        updated_pipe = fcc.update_deployment_pipeline(deployment_pipeline_id=pipe.id, display_name="sdknewname", description="newdescription")
+        self.assertIsNotNone(updated_pipe.id)
+
+        pipe = fcc.get_deployment_pipeline(pipe_id)
+        self.assertIsNotNone(pipe.id)
+        self.assertTrue(pipe.display_name == "sdknewname")
+
+        updated_stage = fcc.update_deployment_pipeline_stage(deployment_pipeline_id=pipe_id, stage_id=prod_stage["id"],
+                                                     display_name="newname", description="newdescription")
+        self.assertIsNotNone(updated_stage["id"])
+
+        stage = fcc.get_deployment_pipeline_stage(deployment_pipeline_id=pipe_id, stage_id=prod_stage["id"])
+        self.assertIsNotNone(stage.id)
+        self.assertTrue(stage.display_name == "newname")
+
+        for _ in range(10):
+            ops = fcc.get_deployment_pipeline_operation(deployment_pipeline_id=pipe_id, operation_id=ops["id"])
+            if ops["status"] != "Running":
+                break
+            else:
+                time.sleep(5)
+
+        resp = fcc.unassign_workspace_from_stage(deployment_pipeline_id=pipe_id,stage_id=prod_stage["id"])
+        self.assertEqual(resp, 200)
+
+        prod_workspace.delete()
+
+        resp = fcc.delete_deployment_pipeline(deployment_pipeline_id=pipe_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

@@ -0,0 +1,119 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
+
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+
+                  
+    def test_domains(self):
+        fcc = FabricClientCore()
+        fca = FabricClientAdmin()
+
+        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
+        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")
+        domain = fca.create_domain(display_name=domain_name)
+        self.assertIsNotNone(domain.id)
+        self.assertEqual(domain.display_name, domain_name)
+
+        # Get domain by name
+        domain_clone = fca.get_domain_by_name(domain_name)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # Get domain by id
+        domain_clone = fca.get_domain_by_id(domain.id)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # List domains
+        domains = fca.list_domains()
+        self.assertGreater(len(domains), 0)
+        domains_ids = [d.id for d in domains]
+        self.assertIn(domain.id, domains_ids)
+
+        # Update domain
+        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
+        status_code = fca.assign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        # List domain workspaces
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=False)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w["id"] for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign domain workspaces by ids
+        status_code = fca.unassign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by capacities
+        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=False)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w["id"] for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign all domain workspaces
+        status_code = fca.unassign_all_domain_workspaces(domain.id)
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by principals
+        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=False)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w["id"] for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Role assignments bulk assign
+        
+        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)
+
+        self.assertEqual(status_code, 200)
+
+        # Role assignments bulk unassign
+        status_code = fca.role_assignments_bulk_unassign(domain.id, "Contributors", [principal_2])
+
+        self.assertEqual(status_code, 200)
+
+        # Delete domain
+        status_code = fca.delete_domain(domain.id)
+
+        self.assertEqual(status_code, 200)
+
+        domains = fca.list_domains()
+        domains_ids = [d.id for d in domains]
+        self.assertNotIn(domain.id, domains_ids)

msfabricpysdkcore/tests/test_environments.py

@@ -0,0 +1,121 @@
+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)
+        self.fc = FabricClientCore()
+
+    def test_environments_crudl(self):
+        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)
+
+
+        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}"
+
+        environment_new = fcc.create_environment(workspace_id=workspace_id, display_name=date_str)
+
+        self.assertEqual(environment_new.display_name, date_str)
+
+        environment_get = fcc.get_environment(workspace_id=workspace_id, environment_id=environment_new.id)
+        self.assertEqual(environment_get.display_name, date_str)
+
+        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 = '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)
+        self.assertIn("dynamicExecutorAllocation", published_settings)
+        staging_settings = fc.get_staging_settings(workspace_id=workspace_id, environment_id=environment_id)
+        self.assertIsNotNone(staging_settings)
+        self.assertIn("instancePool", staging_settings)
+        self.assertIn("dynamicExecutorAllocation", staging_settings)
+        if staging_settings["driverCores"] == 8:
+            driver_cores = 4
+        else:
+            driver_cores = 8
+        updated_settings = fc.update_staging_settings(workspace_id=workspace_id, environment_id=environment_id, driver_cores=driver_cores)
+        self.assertIn("instancePool", updated_settings)
+        self.assertIn("dynamicExecutorAllocation", updated_settings)
+        self.assertEqual(updated_settings["driverCores"], driver_cores)
+        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)
+
+
+    def test_environment_spark_libraries(self):
+        fc = self.fc
+        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.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)
+        
+        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'])
+
+        
+        resp = fc.publish_environment(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'].lower(), 'running')
+
+        
+        resp = fc.cancel_publish(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'].lower(), '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'])
+
+
+        
+
+
+

msfabricpysdkcore/tests/test_evenstreams.py

@@ -0,0 +1,57 @@
+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_eventstreams(self):
+
+        fcc = self.fc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "94f4b54b-980b-43f9-8b67-ded8028cf1b9"
+
+        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)
+
+        eventstream_definition = fcc.get_eventstream_definition(workspace_id=workspace_id, eventstream_id=item_id)
+        self.assertIn("definition", eventstream_definition)
+        definition = eventstream_definition["definition"]
+
+        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}"
+
+        eventstream_new = fcc.create_eventstream(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(eventstream_new.display_name, date_str)
+
+        eventstream_get = fcc.get_eventstream(workspace_id=workspace_id, eventstream_id=eventstream_new.id)
+        self.assertEqual(eventstream_get.display_name, date_str)
+
+        eventstreams = fcc.list_eventstreams(workspace_id=workspace_id)
+        self.assertEqual(len(eventstreams), 2)
+
+        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_eventstream_topology.py

@@ -0,0 +1,82 @@
+
+# import unittest
+# from dotenv import load_dotenv
+# from msfabricpysdkcore import FabricClientCore
+# from datetime import datetime
+# from time import sleep
+# load_dotenv()
+
+# class TestFabricClientCore(unittest.TestCase):
+
+#     def __init__(self, *args, **kwargs):
+#         super(TestFabricClientCore, self).__init__(*args, **kwargs)
+                  
+#     def test_eventstream_topology(self):
+
+        # fcc = FabricClientCore()
+
+        # workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+
+        # item_id = "94f4b54b-980b-43f9-8b67-ded8028cf1b9"
+        # custom_destination_id = "acd90d61-2792-4494-9f17-c822f2fb984d"
+        # custom_source_id = "9f382928-7d42-43f9-b02b-1b1352ad3ecd"
+        # source_id = "e58db369-e473-40f4-bedd-022b60540b17"
+        # destination_id = "2446e6cf-98c9-45cb-a102-78d2ca3eb257"
+
+
+        # topology = fcc.get_eventstream_topology(workspace_id, item_id)
+        # self.assertIsNotNone(topology)
+        # self.assertIn("sources", topology)
+        # self.assertIn("destinations", topology)
+
+        # destination = fcc.get_eventstream_destination(workspace_id, item_id, destination_id)
+        # self.assertIsNotNone(destination)
+        # self.assertEqual(destination["id"], destination_id)
+
+        # destination_conn = fcc.get_eventstream_destination_connection(workspace_id, item_id, custom_destination_id)
+        # self.assertIsNotNone(destination_conn)
+        # self.assertIn("fullyQualifiedNamespace", destination_conn)
+
+        # source = fcc.get_eventstream_source(workspace_id, item_id, source_id)
+        # self.assertIsNotNone(source)
+        # self.assertEqual(source["id"], source_id)
+
+        # source_conn = fcc.get_eventstream_source_connection(workspace_id, item_id, custom_source_id)
+        # self.assertIsNotNone(source_conn)
+        # self.assertIn("fullyQualifiedNamespace", source_conn)
+
+        # resp = fcc.pause_eventstream(workspace_id, item_id)
+        # self.assertEqual(resp, 200)
+
+        # def resume():
+        #     resp = fcc.resume_eventstream(workspace_id, item_id, start_type="Now")
+        #     self.assertEqual(resp, 200)
+
+        # for _ in range(12):
+        #     try:
+        #         resume()
+        #         break
+        #     except Exception as e:
+        #         sleep(5)
+        
+        # resp = fcc.pause_eventstream_source(workspace_id, item_id, source_id)
+        # self.assertEqual(resp, 200)
+
+        # resp = fcc.pause_eventstream_destination(workspace_id, item_id, destination_id)
+        # self.assertEqual(resp, 200)
+
+        # resp = fcc.resume_eventstream_source(workspace_id, item_id, source_id, start_type="Now")
+        # self.assertEqual(resp, 200)
+
+        # def resume():
+        #     resp = fcc.resume_eventstream_destination(workspace_id, item_id, destination_id, start_type="Now")
+        #     self.assertEqual(resp, 200)
+        
+        # for _ in range(12):
+        #     try:
+        #         resume()
+        #         break
+        #     except Exception as e:
+        #         sleep(5)
+
+