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

msfabricpysdkcore/tests/test_connection.py

@@ -1,111 +0,0 @@
-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_copy_jobs.py

@@ -1,60 +0,0 @@
-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_copy_jobs(self):
-        fcc = self.fcc
-
-        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
-        item_id = "a9e59ec1-524b-49b1-a185-37e47dc0ceb9"
-
-        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
-        for copy_job in copy_jobs:
-            if copy_job.id != item_id:
-                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
-                self.assertEqual(resp, 200)
-
-        copy_job_definition = fcc.get_copy_job_definition(workspace_id=workspace_id, copy_job_id=item_id)
-        self.assertIn("definition", copy_job_definition)
-        definition = copy_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}"
-
-        copy_job_new = fcc.create_copy_job(workspace_id=workspace_id, display_name=date_str, definition=definition)
-
-        self.assertEqual(copy_job_new.display_name, date_str)
-
-        copy_job_get = fcc.get_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id)
-        self.assertEqual(copy_job_get.display_name, date_str)
-
-        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
-        self.assertEqual(len(copy_jobs), 2)
-
-        date_str_updated = date_str + "_updated"
-        copy_job_updated = fcc.update_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id, display_name=date_str_updated, return_item=True)
-        self.assertEqual(copy_job_updated.display_name, date_str_updated)
-
-        copy_job_updated = fcc.update_copy_job_definition(workspace_id=workspace_id, copy_job_id=copy_job_new.id, definition=definition)
-        self.assertEqual(copy_job_updated.status_code, 200)
-
-        for copy_job in copy_jobs:
-            if copy_job.id != item_id:
-                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
-                self.assertEqual(resp, 200)
-
-
-
-
-
-
-

msfabricpysdkcore/tests/test_dataflows.py

@@ -1,60 +0,0 @@
-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_dataflows(self):
-        fcc = self.fcc
-
-        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
-        item_id = "8bc6f2f1-2ef9-4dc1-ab47-f55aa90e4088"
-
-        dataflows = fcc.list_dataflows(workspace_id=workspace_id)
-        for dataflow in dataflows:
-            if dataflow.id != item_id:
-                resp = fcc.delete_dataflow(workspace_id=workspace_id, dataflow_id=dataflow.id)
-                self.assertEqual(resp, 200)
-
-        dataflow_definition = fcc.get_dataflow_definition(workspace_id=workspace_id, dataflow_id=item_id)
-        self.assertIn("definition", dataflow_definition)
-        definition = dataflow_definition["definition"]
-
-        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
-        date_str = f"dataflow{date_str}"
-
-        dataflow_new = fcc.create_dataflow(workspace_id=workspace_id, display_name=date_str, definition=definition)
-
-        self.assertEqual(dataflow_new.display_name, date_str)
-
-        dataflow_get = fcc.get_dataflow(workspace_id=workspace_id, dataflow_id=dataflow_new.id)
-        self.assertEqual(dataflow_get.display_name, date_str)
-
-        dataflows = fcc.list_dataflows(workspace_id=workspace_id)
-        self.assertEqual(len(dataflows), 2)
-
-        date_str_updated = date_str + "_updated"
-        dataflow_updated = fcc.update_dataflow(workspace_id=workspace_id, dataflow_id=dataflow_new.id, display_name=date_str_updated, return_item=True)
-        self.assertEqual(dataflow_updated.display_name, date_str_updated)
-
-        dataflow_updated = fcc.update_dataflow_definition(workspace_id=workspace_id, dataflow_id=dataflow_new.id, definition=definition)
-        self.assertEqual(dataflow_updated.status_code, 200)
-
-        for dataflow in dataflows:
-            if dataflow.id != item_id:
-                resp = fcc.delete_dataflow(workspace_id=workspace_id, dataflow_id=dataflow.id)
-                self.assertEqual(resp, 200)
-
-
-
-
-
-
-

msfabricpysdkcore/tests/test_datapipelines.py

@@ -1,60 +0,0 @@
-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_data_pipelines(self):
-        fcc = self.fcc
-
-        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
-        item_id = "b7746e38-5409-487a-969c-fb7cb026b5d3"
-
-        data_pipelines = fcc.list_data_pipelines(workspace_id=workspace_id)
-        for data_pipeline in data_pipelines:
-            if data_pipeline.id != item_id:
-                resp = fcc.delete_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline.id)
-                self.assertEqual(resp, 200)
-
-        data_pipeline_definition = fcc.get_data_pipeline_definition(workspace_id=workspace_id, data_pipeline_id=item_id)
-        self.assertIn("definition", data_pipeline_definition)
-        definition = data_pipeline_definition["definition"]
-
-        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
-        date_str = f"data_pipeline{date_str}"
-
-        data_pipeline_new = fcc.create_data_pipeline(workspace_id=workspace_id, display_name=date_str, definition=definition)
-
-        self.assertEqual(data_pipeline_new.display_name, date_str)
-
-        data_pipeline_get = fcc.get_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id)
-        self.assertEqual(data_pipeline_get.display_name, date_str)
-
-        data_pipelines = fcc.list_data_pipelines(workspace_id=workspace_id)
-        self.assertEqual(len(data_pipelines), 2)
-
-        date_str_updated = date_str + "_updated"
-        data_pipeline_updated = fcc.update_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id, display_name=date_str_updated, return_item=True)
-        self.assertEqual(data_pipeline_updated.display_name, date_str_updated)
-
-        data_pipeline_updated = fcc.update_data_pipeline_definition(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id, definition=definition)
-        self.assertEqual(data_pipeline_updated.status_code, 200)
-
-        for data_pipeline in data_pipelines:
-            if data_pipeline.id != item_id:
-                resp = fcc.delete_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline.id)
-                self.assertEqual(resp, 200)
-
-
-
-
-
-
-

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -1,63 +0,0 @@
-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_deployment_pipelinev2.py

@@ -1,135 +0,0 @@
-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_domains.py

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