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

msfabricpysdkcore/tests/test_ml_experiments.py

@@ -0,0 +1,47 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+
+    
+    def test_ml_experiments(self):
+            
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        mlexperiment_name = "mlexp" + datetime.now().strftime("%Y%m%d%H%M%S")
+        mlexperiment_name2 = "mlexp2" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        ml_experiment = fc.create_ml_experiment(workspace_id, display_name=mlexperiment_name)
+        self.assertEqual(ml_experiment.display_name, mlexperiment_name)
+        
+        ml_experiments = fc.list_ml_experiments(workspace_id)
+        ml_experiment_names = [mle.display_name for mle in ml_experiments]
+        self.assertGreater(len(ml_experiments), 0)
+        self.assertIn(mlexperiment_name, ml_experiment_names)
+
+        mle = fc.get_ml_experiment(workspace_id, ml_experiment_name=mlexperiment_name)
+        self.assertIsNotNone(mle.id)
+        self.assertEqual(mle.display_name, mlexperiment_name)
+
+        mle2 = fc.update_ml_experiment(workspace_id, mle.id, display_name=mlexperiment_name2, return_item=True)
+
+        mle = fc.get_ml_experiment(workspace_id, ml_experiment_id=mle.id)
+        self.assertEqual(mle.display_name, mlexperiment_name2)
+        self.assertEqual(mle.id, mle2.id)
+
+        status_code = fc.delete_ml_experiment(workspace_id, mle.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_ml_models.py

@@ -0,0 +1,47 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+
+    
+    def test_ml_models(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        model_name = "mlm" + datetime_str
+
+        ml_model = fc.create_ml_model(workspace_id, display_name=model_name)
+        self.assertEqual(ml_model.display_name, model_name)
+        
+        ml_models = fc.list_ml_models(workspace_id)
+        ml_model_names = [ml.display_name for ml in ml_models]
+        self.assertGreater(len(ml_models), 0)
+        self.assertIn(model_name, ml_model_names)
+
+        mlm = fc.get_ml_model(workspace_id, ml_model_name=model_name)
+        self.assertIsNotNone(mlm.id)
+        self.assertEqual(mlm.display_name, model_name)
+
+        mlm2 = fc.update_ml_model(workspace_id=workspace_id,ml_model_id= mlm.id,  description=model_name, return_item=True)
+
+        mlm = fc.get_ml_model(workspace_id, ml_model_id=mlm.id)
+        self.assertEqual(mlm.description, model_name)
+        self.assertEqual(mlm.id, mlm2.id)
+
+        status_code = fc.delete_ml_model(workspace_id, mlm.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_notebooks.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()
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+
+    
+    def test_notebooks(self):
+            
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        notebook_name = "notebook" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        notebook_w_content = fc.get_notebook(workspace_id, notebook_name="HelloWorld")
+
+        definition = fc.get_notebook_definition(workspace_id, notebook_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+        notebook = fc.create_notebook(workspace_id, definition=definition, display_name=notebook_name)
+        fc.update_notebook_definition(workspace_id, notebook.id, definition=definition)
+        notebook = fc.get_notebook(workspace_id, notebook_id=notebook.id)
+        self.assertEqual(notebook.display_name, notebook_name)
+        self.assertIsNotNone(notebook.definition)
+        
+        notebooks = fc.list_notebooks(workspace_id)
+        notebook_names = [nb.display_name for nb in notebooks]
+        self.assertGreater(len(notebooks), 0)
+        self.assertIn(notebook_name, notebook_names)
+
+        nb = fc.get_notebook(workspace_id, notebook_name=notebook_name)
+        self.assertIsNotNone(nb.id)
+        self.assertEqual(nb.display_name, notebook_name)
+
+        nb2 = fc.update_notebook(workspace_id, notebook_id=nb.id, display_name=f"{notebook_name}2", return_item=True)
+
+        nb = fc.get_notebook(workspace_id, notebook_id=nb.id)
+        self.assertEqual(nb.display_name, f"{notebook_name}2")
+        self.assertEqual(nb.id, nb2.id)
+
+        status_code = fc.delete_notebook(workspace_id, nb.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_one_lake_data_access_security.py

@@ -14,8 +14,8 @@ class TestFabricClientCore(unittest.TestCase):
 
         fc = self.fc
 
-        workspace_id = "d8a5abe0-9eed-406d-ab46-343bc57ddbe5"
-        item_id = "50368cf3-29e7-4a09-aaf0-289fb5748364"
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        item_id = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
 
         resp = fc.list_data_access_roles(workspace_id=workspace_id, item_id=item_id)
         self.assertEqual(len(resp), 2)
@@ -30,8 +30,6 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertGreater(len(role1['members']['fabricItemMembers']), 0)
         self.assertIn('itemAccess', role1['members']['fabricItemMembers'][0])
 
-
-
         item_access = role1["members"]["fabricItemMembers"][0]['itemAccess']
         item_access_old = list(item_access)
         if 'ReadAll' in item_access:

msfabricpysdkcore/tests/test_other_items.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()
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+    
+    def test_list_other_items(self):
+
+        fc = self.fc
+
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        list_dashboards = fc.list_dashboards(workspace_id)
+        dashboard_names = [dashboard.display_name for dashboard in list_dashboards]
+        self.assertGreater(len(list_dashboards), 0)
+        self.assertIn("dashboard1", dashboard_names)
+
+        # list_datamarts = fc.list_datamarts(workspace_id)
+        # datamart_names = [datamart.display_name for datamart in list_datamarts]
+        # self.assertGreater(len(list_datamarts), 0)
+        # self.assertIn("datamart1", datamart_names)
+
+        list_sql_endpoints = fc.list_sql_endpoints(workspace_id)
+        sqlendpoint_names = [sqlendpoint.display_name for sqlendpoint in list_sql_endpoints]
+        self.assertGreater(len(list_sql_endpoints), 0)
+        self.assertIn("lakelhousewlabels", sqlendpoint_names)
+
+        # list_mirrored_warehouses = fc.list_mirrored_warehouses(self.workspace_id)
+        # self.assertGreater(len(list_mirrored_warehouses), 0)
+
+        # list_paginated_reports = fc.list_paginated_reports(self.workspace_id)
+        # self.assertGreater(len(list_paginated_reports), 0)

msfabricpysdkcore/tests/test_reports.py

@@ -0,0 +1,52 @@
+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_reports(self):
+                
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        report_name = "report1234"
+
+        report_w_content = fc.get_report(workspace_id, report_name="HelloWorldReport")
+
+        definition = fc.get_report_definition(workspace_id, report_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
+        report = fc.create_report(workspace_id, display_name=report_name, definition=definition)
+        fc.update_report_definition(workspace_id, report.id, definition=definition)
+        report = fc.get_report(workspace_id, report_id=report.id)
+        self.assertEqual(report.display_name, report_name)
+        self.assertIsNotNone(report.definition)
+        
+        reports = fc.list_reports(workspace_id)
+        report_names = [r.display_name for r in reports]
+        self.assertGreater(len(reports), 0)
+        self.assertIn(report_name, report_names)
+
+        r = fc.get_report(workspace_id, report_name=report_name)
+        self.assertIsNotNone(r.id)
+        self.assertEqual(r.display_name, report_name)
+
+        status_code = fc.delete_report(workspace_id, r.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_semantic_model.py

@@ -0,0 +1,50 @@
+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_semantic_models(self):
+                    
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        semantic_model_name = "semanticmodel" + datetime_str
+
+        semantic_model_w_content = fc.get_semantic_model(workspace_id, semantic_model_name="Table")
+
+        definition = fc.get_semantic_model_definition(workspace_id, semantic_model_w_content.id)
+
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+        semantic_model = fc.create_semantic_model(workspace_id, display_name=semantic_model_name, definition=definition)
+        fc.update_semantic_model_definition(workspace_id, semantic_model.id, definition=definition)
+        semantic_model = fc.get_semantic_model(workspace_id, semantic_model_id=semantic_model.id)
+        self.assertEqual(semantic_model.display_name, semantic_model_name)
+        self.assertIsNotNone(semantic_model.definition)
+        
+        semantic_models = fc.list_semantic_models(workspace_id)
+        semantic_model_names = [sm.display_name for sm in semantic_models]
+        self.assertGreater(len(semantic_models), 0)
+        self.assertIn(semantic_model_name, semantic_model_names)
+
+        sm = fc.get_semantic_model(workspace_id, semantic_model_name=semantic_model_name)
+        self.assertIsNotNone(sm.id)
+        self.assertEqual(sm.display_name, semantic_model_name)
+
+        status_code = fc.delete_semantic_model(workspace_id, sm.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_shortcuts.py

@@ -11,14 +11,14 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
+        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
 
-        self.lakehouse_target = "cb4ca0b5-b53b-4879-b206-a53c35cbff55"
-        self.lakehouse_shortcut = "e2c09c89-bf97-4f71-bdeb-36338795ec36"
+        self.lakehouse_target = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
+        self.lakehouse_shortcut = "9d1e8b07-2fea-4fc5-872c-fb586d085149"
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         self.shortcutname = "shortcut" + datetime_str
-        self.path_target = "Files/folder1"
+        self.path_target = "Files/to_share"
         self.path_shortcut = "Files/shortcutfolder"
 
         self.target = {'oneLake': {'itemId': self.lakehouse_target,

msfabricpysdkcore/tests/test_spark.py

@@ -1,6 +1,7 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
 from dotenv import load_dotenv
+from datetime import datetime
 
 load_dotenv()
 
@@ -11,14 +12,12 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        ws = self.fc.get_workspace_by_name(name="testitems")
-        self.workspace_id = ws.id
 
 
     def test_spark_workspace_custom_pools(self):
         fc = self.fc
-        workspace_id = self.workspace_id
-
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        pool_name = "pool" + datetime.now().strftime("%Y%m%d%H%M%S")
         # List 
 
         pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
@@ -36,19 +35,20 @@ class TestFabricClientCore(unittest.TestCase):
         # Create
 
         pool2 = fc.create_workspace_custom_pool(workspace_id=workspace_id, 
-                                        name="pool2", 
+                                        name=pool_name, 
                                         node_family="MemoryOptimized",
                                         node_size="Small", 
                                         auto_scale = {"enabled": True, "minNodeCount": 1, "maxNodeCount": 2},
                                         dynamic_executor_allocation = {"enabled": True, "minExecutors": 1, "maxExecutors": 1})
 
-        self.assertEqual(pool2.name, "pool2")
+        self.assertEqual(pool2.name, pool_name)
         self.assertEqual(pool2.node_family, "MemoryOptimized")
 
         # Update
 
         pool2 = fc.update_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id,
-                                        auto_scale = {"enabled": True, "minNodeCount": 1, "maxNodeCount": 7})
+                                        auto_scale = {"enabled": True, "minNodeCount": 1, "maxNodeCount": 7},
+                                        return_item=True)
 
         self.assertEqual(pool2.auto_scale["maxNodeCount"], 7)
         pool2_clone = fc.get_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id)
@@ -59,11 +59,11 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(status_code, 200)
 
         pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
-        self.assertNotIn("pool2", [p.name for p in pools])
+        self.assertNotIn(pool_name, [p.name for p in pools])
 
     def test_workspace_settings(self):
         fc = self.fc
-        workspace_id = self.workspace_id
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
 
         # Get
 

msfabricpysdkcore/tests/test_sparkjobdefinition.py

@@ -14,7 +14,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_spark_job_definitions(self):
         
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         spark_job_definition_name = f"sjd{datetime_str}"
@@ -47,7 +47,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIsNotNone(sjd.id)
         self.assertEqual(sjd.display_name, spark_job_definition_name)
 
-        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2")
+        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2", return_item=True)
         sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
         self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
 

msfabricpysdkcore/tests/test_warehouses.py

@@ -0,0 +1,50 @@
+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_warehouses(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        warehouse1 = f"wh{datetime_str}"
+        warehouse = fc.create_warehouse(workspace_id, display_name=warehouse1)
+        self.assertIsNotNone(warehouse.id)
+
+        warehouses = fc.list_warehouses(workspace_id)
+        warehouse_names = [wh.display_name for wh in warehouses]
+        self.assertGreater(len(warehouses), 0)
+        self.assertIn(warehouse1, warehouse_names)
+
+        warehouse = fc.get_warehouse(workspace_id, warehouse_name=warehouse1)
+        self.assertIsNotNone(warehouse.id)
+        self.assertEqual(warehouse.display_name, warehouse1)
+
+        warehouse2 = fc.update_warehouse(workspace_id, warehouse.id, display_name=f"{warehouse1}2", return_item=True)
+        warehouse = fc.get_warehouse(workspace_id, warehouse_id=warehouse.id)
+        self.assertEqual(warehouse.display_name, f"{warehouse1}2")
+        self.assertEqual(warehouse.id, warehouse2.id)
+
+        status_code = fc.delete_warehouse(workspace_id, warehouse.id)
+        self.assertEqual(status_code, 200)
+
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -16,6 +16,9 @@ class TestFabricClientCore(unittest.TestCase):
         fc = self.fc
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         display_name = "testws" + datetime_str
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        workspace_name_new = "newws" + datetime_str
         ws_created = fc.create_workspace(display_name=display_name,
                                               description="test workspace", 
                                               exists_ok=False)
@@ -29,7 +32,7 @@ class TestFabricClientCore(unittest.TestCase):
 #   def test_assign_to_capacity(self):
         
         result_status_code = fc.assign_to_capacity(workspace_id=ws.id, 
-                                                        capacity_id="41cb829c-c231-4e9f-b4fc-f9042a6f9840")
+                                                        capacity_id="840a6c1e-5289-4094-bbc8-716daabaeeba")
         self.assertEqual(result_status_code, 202)
       
 
@@ -41,7 +44,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         for ws in result:
             if ws.display_name == display_name:
-                self.assertEqual(ws.capacity_id, "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
+                self.assertEqual(ws.capacity_id, "840a6c1e-5289-4094-bbc8-716daabaeeba")
 
 
   #  def test_get_workspace_by_name(self):
@@ -61,7 +64,7 @@ class TestFabricClientCore(unittest.TestCase):
     
  #   def test_add_role_assignment(self):
         result_status = fc.add_workspace_role_assignment(workspace_id = ws.id,
-                                                         principal = {"id" : "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69",
+                                                         principal = {"id" : "755f273c-98f8-408c-a886-691794938bd8",
                                                                         "type" : "ServicePrincipal"},
                                                          role = 'Member')
         
@@ -77,7 +80,7 @@ class TestFabricClientCore(unittest.TestCase):
         # Get get_workspace_role_assignment
 
         result = fc.get_workspace_role_assignment(workspace_id = ws.id, 
-                                                  workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+                                                  workspace_role_assignment_id = "755f273c-98f8-408c-a886-691794938bd8")
         
         self.assertEqual(result["role"], "Member")
 
@@ -85,7 +88,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         result_status_code = fc.update_workspace_role_assignment(workspace_id = ws.id, 
                                                                       role = "Contributor", 
-                                                                      workspace_role_assignment_id= "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+                                                                      workspace_role_assignment_id= "755f273c-98f8-408c-a886-691794938bd8")
         
         self.assertEqual(result_status_code, 200)
 
@@ -97,7 +100,7 @@ class TestFabricClientCore(unittest.TestCase):
 
 #   def test_delete_role_assignment(self):
         result_status_code = fc.delete_workspace_role_assignment(workspace_id = ws.id,
-                                                                 workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+                                                                 workspace_role_assignment_id = "755f273c-98f8-408c-a886-691794938bd8")
         self.assertEqual(result_status_code, 200)
 
  #   def test_get_workspace_role_assignments(self):
@@ -109,12 +112,12 @@ class TestFabricClientCore(unittest.TestCase):
 
 #    def test_update_workspace(self):
         ws_updated = fc.update_workspace(workspace_id=ws.id, 
-                                              display_name="newn912389u8293", 
+                                              display_name=workspace_name_new, 
                                               description="new description")
-        self.assertEqual(ws_updated.display_name, "newn912389u8293")
+        self.assertEqual(ws_updated.display_name, workspace_name_new)
         self.assertEqual(ws_updated.description, "new description")
         ws = fc.get_workspace_by_id(id = ws.id)
-        self.assertEqual(ws.display_name, "newn912389u8293")
+        self.assertEqual(ws.display_name, workspace_name_new)
         self.assertEqual(ws.description, "new description")
 
 #    def test_unassign_from_capacity(self):
@@ -131,18 +134,18 @@ class TestFabricClientCore(unittest.TestCase):
 
 
 #    def test_delete_workspace(self):
-        result_status = fc.delete_workspace(display_name="newn912389u8293")
+        result_status = fc.delete_workspace(display_name=workspace_name_new)
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):
         result = self.fc.list_capacities()
         self.assertTrue(len(result) > 0)
         cap_ids = [cap.id for cap in result]
-        self.assertIn("41cb829c-c231-4e9f-b4fc-f9042a6f9840", cap_ids)
+        self.assertIn("c861242b-c4ac-4e3a-9a21-13f65d9b17b2", cap_ids)
 
     def test_get_capacity(self):
-        capacity = self.fc.get_capacity(capacity_id = "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
-        self.assertEqual(capacity.id, "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
+        capacity = self.fc.get_capacity(capacity_id = "c861242b-c4ac-4e3a-9a21-13f65d9b17b2")
+        self.assertEqual(capacity.id, "c861242b-c4ac-4e3a-9a21-13f65d9b17b2")
 
         cap = self.fc.get_capacity(capacity_name= capacity.display_name)