msfabricpysdkcore 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

msfabricpysdkcore/otheritems.py

@@ -20,6 +20,14 @@ class Eventhouse(Item):
                           properties=item_dict.get('properties', None),
                           description=item_dict.get('description', ""), core_client=core_client)
 
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the eventhouse"""
+        return super().get_definition(type="eventhouses", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the eventhouse"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventhouses")
+
     def create_kql_database(self, display_name = None, description= None):
         from msfabricpysdkcore.coreapi import FabricClientCore
         """Method to create a kql database in the eventhouse"""
@@ -90,6 +98,14 @@ class KQLDatabase(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the kql database"""
+        return super().get_definition(type="kqlDatabases", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the kql database"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlDatabases")
+
 class KQLQueryset(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
@@ -109,6 +125,8 @@ class KQLQueryset(Item):
         """Method to update the definition of the kql queryset"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlQuerysets",
                                                        update_metadata=update_metadata)
+    
+    
 
 class Eventstream(Item):
     """Class to represent a eventstream in Microsoft Fabric"""
@@ -121,6 +139,25 @@ class Eventstream(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the eventstream"""
+        return super().get_definition(type="eventstreams", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the eventstream"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventstreams")
+
+class GraphQLApi(Item):
+    """Class to represent a graphql api 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 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"""
      
@@ -177,6 +214,25 @@ class MLModel(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
+class MountedDataFactory(Item):
+    """Class to represent a mounted data factory 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 MountedDataFactory(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 get_definition(self, type=None, format=None):
+        """Method to get the definition of the mountedDataFactory"""
+        return super().get_definition(type="mountedDataFactories", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the mountedDataFactory"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="mountedDataFactories")
+
 class Notebook(Item):
     """Class to represent a notebook in Microsoft Fabric"""
      
@@ -196,6 +252,25 @@ class Notebook(Item):
         """Method to update the definition of the notebook"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="notebooks")
 
+class Reflex(Item):
+    """Class to represent a reflex 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 Reflex(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 get_definition(self, type=None, format=None):
+        """Method to get the definition of the reflex"""
+        return super().get_definition(type="reflexes", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the reflex"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="reflexes")
+    
 class Report(Item):
     """Class to represent a report in Microsoft Fabric"""
      
@@ -234,6 +309,17 @@ class SemanticModel(Item):
         """Method to update the definition of the semantic model"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="semanticModels")
 
+class SQLDatabase(Item):
+    """Class to represent a sql database 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 SQLDatabase(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 DataPipeline(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
@@ -245,6 +331,13 @@ class DataPipeline(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
+    def get_definition(self, type=None, format=None, **kwargs):
+        return super().get_definition(type="dataPipelines", format=format, **kwargs)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the dataPipeline"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="dataPipelines")
+    
     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)
     

msfabricpysdkcore/tests/test_admin_apis.py

@@ -0,0 +1,174 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fca = FabricClientAdmin()
+                  
+    def test_admin_api(self):
+        fca = self.fca
+
+        user_id = '1dc64c6e-7a10-4ea9-8488-85d0739a377d'
+
+        # List workspaces
+        ws = fca.list_workspaces(name="testitems")[0]
+
+        self.assertEqual(ws.name, "testitems")
+
+        # Get workspace
+        ws_clone = fca.get_workspace(workspace_id=ws.id)
+
+        self.assertEqual(ws.id, ws_clone.id)
+
+        # Discover git connections 
+      
+        git_connections = fca.discover_git_connections()
+
+        self.assertGreater(len(git_connections), 0)
+
+        git_conn = [g for g in git_connections if g['workspaceId'] == '63aa9e13-4912-4abe-9156-8a56e565b7a3'][0]
+        self.assertEqual(git_conn['gitProviderDetails']['ownerName'], 'DaSenf1860')
+
+        # List workspace access details
+
+        ws_access = fca.list_workspace_access_details(ws.id)
+        principials = ws_access["accessDetails"]
+        principials_ids = [p["principal"]["id"] for p in principials]
+        self.assertIn(user_id, principials_ids)
+
+        # Get access entities
+
+        access_entities = fca.list_access_entities(user_id, type="Notebook")
+        self.assertGreater(len(access_entities), 0)
+
+        # List tenant settings
+    
+        settings = fca.list_tenant_settings()
+        monitoring_setting = [setting for setting in settings if setting['settingName'] == 'PlatformMonitoringTenantSetting'][0]
+
+        self.assertIsNotNone(monitoring_setting)
+ 
+        # List tenant settings capacity overrides
+    
+        settings_capa = fca.list_capacities_tenant_settings_overrides()
+        setting = [s for s in settings_capa if s['id'] == '9E7E757D-D567-4FB3-BC4F-D230AABF2A00']
+
+        self.assertGreater(len(setting), 0)
+
+ 
+        # List tenant settings overrides on domains
+
+        domain_overrides = fca.list_domain_tenant_settings_overrides()
+        len(domain_overrides) == 0 
+        self.assertEqual(len(domain_overrides), 0)
+
+        # List tenant settings overrides on workspaces
+
+        workspace_overrides = fca.list_workspace_tenant_settings_overrides()
+        wover = [w for w in workspace_overrides if w["id"] == "192333b2-5f89-4da5-ae69-64a3ee4c649c"]
+        self.assertIsNotNone(wover)
+
+        # Update tenant settings
+
+        if monitoring_setting["enabled"] == False:
+            changed_settings = fca.update_tenant_setting("PlatformMonitoringTenantSetting", enabled=True)
+            "tenantSettings" in changed_settings and len(changed_settings["tenantSettings"]) > 0 and changed_settings["tenantSettings"][0]["enabled"] == True
+        else: 
+            changed_settings = fca.update_tenant_setting("PlatformMonitoringTenantSetting", enabled=False)
+            "tenantSettings" in changed_settings and len(changed_settings["tenantSettings"]) > 0 and changed_settings["tenantSettings"][0]["enabled"] == False
+
+
+
+        # Update tenant settings capacity overrides
+
+ 
+        enabledSecurityGroups = [{'graphId': '73ba0244-b701-41ed-96d9-79917b74f5f8', 'name': 'fabricadmins'}]
+        excludedSecurityGroups = [{'graphId': '16450670-829a-4b70-b80e-6524eea067cb', 'name': 'fabricuser'}]
+        feedback = fca.update_capacity_tenant_setting_override("9e7e757d-d567-4fb3-bc4f-d230aabf2a00",
+                                                    "PlatformMonitoringTenantSetting",
+                                                    enabled=True,
+                                                    excluded_security_groups=excludedSecurityGroups,
+                                                    enabled_security_groups=enabledSecurityGroups)
+        
+        
+        # List tenant settings overrides by capacity id
+ 
+        settings_capa = fca.list_capacity_tenant_settings_overrides_by_capacity_id("9e7e757d-d567-4fb3-bc4f-d230aabf2a00")
+        setting = [s for s in settings_capa if s['settingName'] == 'PlatformMonitoringTenantSetting']
+
+        self.assertGreater(len(setting), 0)
+
+        # Update tenant settings capacity overrides
+
+        status_code = fca.delete_capacity_tenant_setting_override("9e7e757d-d567-4fb3-bc4f-d230aabf2a00", "PlatformMonitoringTenantSetting")
+
+        self.assertEqual(status_code, 200)
+
+        settings = [set for set in fca.list_capacity_tenant_settings_overrides_by_capacity_id("9e7e757d-d567-4fb3-bc4f-d230aabf2a00") if set["settingName"] == "PlatformMonitoringTenantSetting"]
+
+        self.assertEqual(len(settings), 0)
+
+        self.assertIn("overrides", feedback)
+        self.assertGreater(len(feedback["overrides"]), 0)
+        self.assertEqual(feedback["overrides"][0]["enabled"], True)
+
+ 
+
+
+
+
+
+        # List items
+
+        item_list = fca.list_items(workspace_id=ws.id)
+        self.assertGreater(len(item_list), 0)
+
+        # Get item
+
+        item = fca.get_item(workspace_id=ws.id, item_id=item_list[0].id)
+        self.assertEqual(item.id, item_list[0].id)
+
+        # Get item access details
+
+        item_access = fca.list_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
+        principials = item_access["accessDetails"]
+
+        principials_ids = [p["principal"]["id"] for p in principials]
+
+        self.assertIn(user_id, principials_ids)
+
+
+    def test_labels(self):
+
+        fca = self.fca
+
+        items = [{"id": "9cdd3192-bcd0-4cbe-b945-29f5964e7ab7", "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")
+        resp = fca.bulk_remove_labels(items=items)
+        self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
+
+    def test_admin_external_data_shares(self):
+
+        fca = self.fca
+
+        data_shares = fca.list_external_data_shares()
+        ws_id = "63aa9e13-4912-4abe-9156-8a56e565b7a3"
+
+        data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
+
+        self.assertGreater(len(data_shares), 0)
+        # fca.revoke_external_data_share(external_data_share_id = data_shares[0]['id'], 
+        #                                item_id = data_shares[0]['itemId'], 
+        #                                workspace_id = data_shares[0]['workspaceId'])
+        # data_shares = fca.list_external_data_shares()
+
+        # data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
+
+        # self.assertEqual(data_shares[0]['status'], 'Revoked')

msfabricpysdkcore/tests/test_connection.py

@@ -0,0 +1,111 @@
+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_connection(self):
+
+        datetime_str = datetime.now().strftime("%Y%m%H%M%S")
+        datetime_str
+        fc = self.fc
+
+        # display_name = "ContosoCloudConnection" + datetime_str
+
+        # cr = {"connectivityType": "ShareableCloud",
+        #     "displayName": display_name,
+        #     "connectionDetails": {
+        #         'type': "SQL",
+        #         'creationMethod': 'SQL',
+        #         "parameters": [
+        #             {
+        #                 "dataType": "Text",
+        #                 "name": "server",
+        #                 "value": "dfsdemo.database.windows.net"
+        #             },
+        #             {
+        #                 "dataType": "Text",
+        #                 "name": "database",
+        #                 "value": "dfsdemo"
+        #             }
+        #             ]},
+        #     'privacyLevel': 'Organizational',
+        #     'credentialDetails': {'credentials':{'credentialType': 'Basic', 
+        #                                         'userName': 'new_user', 
+        #                                         'password': 'StrongPassword123!'},
+        #                             'singleSignOnType': 'None',
+        #                             'connectionEncryption': 'NotEncrypted',
+        #                             'skipTestConnection': False}
+        # }
+            
+
+
+        # connection = fc.create_connection(connection_request=cr)
+        # self.assertIsNotNone(connection)
+        # self.assertIn('id', connection)
+        # self.assertIn('displayName', connection)
+        # self.assertEqual(connection['displayName'], display_name)
+
+        # connection2 = fc.get_connection(connection_name=display_name)
+        # self.assertEqual(connection['id'], connection2['id'])
+
+
+        # connections = fc.list_connections()
+        # connection_names = [conn['displayName'] for conn in connections]
+        # self.assertIn(display_name, connection_names)
+
+        # id = connection['id']
+
+        # role_assis = fc.list_connection_role_assignments(connection_id=id)
+        # self.assertEqual(len(role_assis), 1)
+
+        # principal = {"id" : "755f273c-98f8-408c-a886-691794938bd8",
+        #             "type" : "ServicePrincipal"}
+
+        # add_role_assi = fc.add_connection_role_assignment(connection_id=id, principal=principal, role='User')
+        # self.assertIsNotNone(add_role_assi)
+        # self.assertIn('id', add_role_assi)
+        # role_assi_id = add_role_assi['id']
+
+        # role_assis = fc.list_connection_role_assignments(connection_id=id)
+        # self.assertEqual(len(role_assis), 2)
+
+        # role_assi = fc.get_connection_role_assignment(connection_id=id,
+        #                                               connection_role_assignment_id=role_assi_id)
+        # self.assertEqual(role_assi['id'], role_assi_id)
+
+        # role_assi = fc.update_connection_role_assignment(connection_id=id,
+        #                                      connection_role_assignment_id=role_assi_id,
+        #                                      role='UserWithReshare')
+        # self.assertEqual(role_assi['role'], 'UserWithReshare')
+
+        # status_code = fc.delete_connection_role_assignment(connection_id=id,
+        #                                                    connection_role_assignment_id=role_assi_id)
+        # self.assertEqual(status_code, 200)
+
+
+        # cr = {
+        # "connectivityType": "ShareableCloud",
+        # "displayName": f"sqlserver{datetime_str}"
+        # }
+
+        # updated_connection = fc.update_connection(connection_id=id, connection_request=cr)
+        # self.assertIsNotNone(updated_connection)
+
+
+        # connection2 = fc.get_connection(connection_id=id)
+        # self.assertEqual(connection['id'], connection2['id'])
+        # self.assertEqual(connection2['displayName'], f"sqlserver{datetime_str}")
+
+        # status_code = fc.delete_connection(connection_id=id)
+        # self.assertEqual(status_code, 200)
+

msfabricpysdkcore/tests/test_datapipelines.py

@@ -0,0 +1,45 @@
+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_data_pipelines(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        pipeline_name = f"pipeline_{datetime_str}"
+
+        dp = fc.create_data_pipeline(workspace_id, display_name=pipeline_name, description="asda")
+        dp.update_definition(dp.definition)
+
+        dps = fc.list_data_pipelines(workspace_id)
+        dp_names = [dp.display_name for dp in dps]
+        self.assertGreater(len(dps), 0)
+        self.assertIn(pipeline_name, dp_names)
+
+        self.assertEqual(dp.display_name, pipeline_name)
+        pipeline_name2 = f"pipeline_{datetime_str}_2"
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name2, return_item=True)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, pipeline_name2)
+        self.assertEqual(dp.id, dp2.id)
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name, return_item=True)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, pipeline_name)
+        self.assertEqual(dp.id, dp2.id)
+        status_code = fc.delete_data_pipeline(workspace_id, dp.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -0,0 +1,63 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+
+
+    def test_spark_workspace_custom_pools(self):
+        fc = self.fc
+
+        dep_pipes = fc.list_deployment_pipelines()
+
+        self.assertGreater(len(dep_pipes), 0)
+
+        self.assertIn("sdkpipe", [pipe.display_name for pipe in dep_pipes])
+
+        for pipe in dep_pipes:
+            if pipe.display_name == 'sdkpipe':
+                pipe_id = pipe.id
+                break
+
+        pipe = fc.get_deployment_pipeline(pipe_id)
+
+        self.assertEqual(pipe.display_name, 'sdkpipe')
+        self.assertEqual(pipe.id, pipe_id)
+
+        stages = fc.list_deployment_pipeline_stages(pipe_id)
+
+        self.assertGreater(len(stages), 0)
+        names = [stage.display_name for stage in stages]
+        self.assertIn("Development", names)
+        self.assertIn("Production", names)
+
+        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.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.list_items() if item["itemDisplayName"] == 'cicdlakehouse']
+        item = items[0]
+        item = {"sourceItemId": item["itemId"],
+                "itemType": item["itemType"]}
+        items = [item]
+
+        response = fc.deploy_stage_content(deployment_pipeline_id=pipe_id, source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+
+        self.assertEqual(response["status"], "Succeeded")
+
+        
+
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -0,0 +1,126 @@
+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("sdktestdomains")
+        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
+
+        # 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=True)
+        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=True)
+        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=True)
+
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        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)