msfabricpysdkcore 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

msfabricpysdkcore/tests/test_admin_apis.py

@@ -1,16 +1,17 @@
 import unittest
-#from dotenv import load_dotenv
+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_domains(self):
-        fca = FabricClientAdmin()
+    def test_admin_api(self):
+        fca = self.fca
 
         user_id = 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2'
 
@@ -26,24 +27,24 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Get workspace access details
 
-        ws_access = fca.get_workspace_access_details(ws.id)
+        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.get_access_entities(user_id, type="Notebook")
+        access_entities = fca.list_access_entities(user_id, type="Notebook")
         self.assertGreater(len(access_entities), 0)
 
         # Get tenant settings
 
-        tenant_settings = fca.get_tenant_settings()
+        tenant_settings = fca.list_tenant_settings()
         self.assertGreater(len(tenant_settings["tenantSettings"]), 0)
 
         # Get capacity tenant settings overrides
 
-        overrides = fca.get_capacities_tenant_settings_overrides()
+        overrides = fca.list_capacities_tenant_settings_overrides()
         self.assertGreater(len(overrides), -1)
 
         # List items
@@ -58,7 +59,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Get item access details
 
-        item_access = fca.get_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
+        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]
@@ -66,3 +67,13 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIn(user_id, principials_ids)
 
 
+    def test_labels(self):
+
+        fca = self.fca
+
+        items = [{"id": "d417b834-d381-454c-9cf0-c491f69508de", "type": "Lakehouse"}]
+        label_id = "defa4170-0d19-0005-000a-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")

msfabricpysdkcore/tests/test_datapipelines.py

@@ -0,0 +1,48 @@
+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 = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        
+        dps = fc.list_data_pipelines(workspace_id)
+        dp_names = [dp.display_name for dp in dps]
+        self.assertGreater(len(dps), 0)
+        self.assertIn("pipeline1", dp_names)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_name="pipeline1")
+        self.assertIsNotNone(dp.id)
+        self.assertIsNotNone(dp.definition)
+        self.assertEqual(dp.display_name, "pipeline1")
+
+        dp_new = fc.create_data_pipeline(workspace_id, display_name="pipeline_new", description="asda")
+        dp_new.update_definition(dp.definition)
+        
+        self.assertEqual(dp_new.display_name, "pipeline_new")
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline2")
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, "pipeline2")
+        self.assertEqual(dp.id, dp2.id)
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline1")
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, "pipeline1")
+        self.assertEqual(dp.id, dp2.id)
+        status_code = fc.delete_data_pipeline(workspace_id, dp_new.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -0,0 +1,64 @@
+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.get_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.get_deployment_pipeline_stages_items(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.get_items() if item["itemDisplayName"] == 'cicdlakehouse']
+        item = items[0]
+        item = {"sourceItemId": item["itemId"],
+                "itemType": item["itemType"]}
+        items = [item]
+
+        
+        response = pipe.deploy(source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+
+        self.assertEqual(response["status"], "Succeeded")
+
+        
+
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -1,9 +1,10 @@
 import unittest
-#from dotenv import load_dotenv
-from datetime import datetime
+from dotenv import load_dotenv
 from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
 
 
+load_dotenv()
+
 class TestFabricClientCore(unittest.TestCase):
 
     def __init__(self, *args, **kwargs):

msfabricpysdkcore/tests/test_environments.py

@@ -0,0 +1,65 @@
+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):
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        env_name = "env" + datetime_str
+        environment1 = fc.create_environment(workspace_id, display_name=env_name)
+        self.assertEqual(environment1.display_name, env_name)
+
+        environments = fc.list_environments(workspace_id)
+        environment_names = [env.display_name for env in environments]
+        self.assertGreater(len(environments), 0)
+        self.assertIn(env_name, environment_names)
+
+        env = fc.get_environment(workspace_id, environment_name=env_name)
+        self.assertIsNotNone(env.id)
+        self.assertEqual(env.display_name, env_name)
+        new_name = env_name + "2"
+        env2 = fc.update_environment(workspace_id, env.id, display_name=new_name)
+
+        env = fc.get_environment(workspace_id, environment_id=env.id)
+        self.assertEqual(env.display_name, new_name)
+        self.assertEqual(env.id, env2.id)
+
+        status_code = fc.delete_environment(workspace_id, env.id)
+        self.assertEqual(status_code, 200)
+
+    def test_environment_details(self):
+        fc = FabricClientCore()
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        environment_id = 'fae6d1a7-d671-4091-89b1-f42626deb56f'
+        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)

msfabricpysdkcore/tests/test_evenstreams.py

@@ -0,0 +1,44 @@
+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):
+
+            fc = self.fc
+            workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+
+            datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+            es_name = "es" + datetime_str
+
+            eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
+            self.assertEqual(eventstream.display_name, es_name)
+
+            eventstreams = fc.list_eventstreams(workspace_id)
+            eventstream_names = [es.display_name for es in eventstreams]
+            self.assertGreater(len(eventstreams), 0)
+            self.assertIn(es_name, eventstream_names)
+
+            
+            es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
+            self.assertIsNotNone(es.id)
+            self.assertEqual(es.display_name, es_name)
+
+            es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2")
+
+            es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
+            self.assertEqual(es.display_name, f"{es_name}2")
+            self.assertEqual(es.id, es2.id)
+
+            status_code = fc.delete_eventstream(workspace_id, es.id)
+            self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_git.py

@@ -1,7 +1,9 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
 from datetime import datetime
-#from dotenv import load_dotenv
+from dotenv import load_dotenv
+
+load_dotenv()
 
 class TestFabricClientCore(unittest.TestCase):
 

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -1,9 +1,11 @@
 import unittest
 from datetime import datetime
-#from dotenv import load_dotenv
+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):
@@ -76,8 +78,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         fc = self.fc
 
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         list_dashboards = fc.list_dashboards(workspace_id)
         dashboard_names = [dashboard.display_name for dashboard in list_dashboards]
@@ -104,24 +105,45 @@ class TestFabricClientCore(unittest.TestCase):
 
         lakehouse = self.fc.get_item(workspace_id=self.workspace_id, item_name="lakehouse1", item_type="Lakehouse")
         self.assertIsNotNone(lakehouse.properties)
-        item_id = lakehouse.id
+        lakehouse_id = lakehouse.id
+        workspace_id = self.workspace_id
         date_str = datetime.now().strftime("%Y%m%d%H%M%S")
         table_name = f"table{date_str}"
 
 
-        status_code = self.fc.load_table(workspace_id=self.workspace_id, item_id=item_id, table_name=table_name, 
+        status_code = self.fc.load_table(workspace_id=self.workspace_id, lakehouse_id=lakehouse_id, table_name=table_name, 
                                          path_type="File", relative_path="Files/folder1/titanic.csv")
 
         self.assertEqual(status_code, 202)
 
-        table_list = self.fc.list_tables(workspace_id=self.workspace_id, item_id=item_id)
+        # Run on demand table maintenance
+        table_name_maintenance = "table20240515114529"
+
+        execution_data = {
+            "tableName": table_name_maintenance,
+            "optimizeSettings": {
+            "vOrder": True,
+            "zOrderBy": [
+                "tipAmount"
+            ]
+            },
+            "vacuumSettings": {
+            "retentionPeriod": "7:01:00:00"
+            }
+        }
+        
+        response = self.fc.run_on_demand_table_maintenance(workspace_id=workspace_id, lakehouse_id=lakehouse_id, 
+                                                           execution_data = execution_data,
+                                                           job_type = "TableMaintenance", wait_for_completion = True)
+        self.assertIn(response.status_code, [200, 202])
+
+        table_list = self.fc.list_tables(workspace_id=self.workspace_id, lakehouse_id=lakehouse_id)
         table_names = [table["name"] for table in table_list]
 
         self.assertIn(table_name, table_names)
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         lakehouse = fc.create_lakehouse(workspace_id=workspace_id, display_name="lakehouse2")
         self.assertIsNotNone(lakehouse.id)
@@ -147,101 +169,37 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(status_code, 200)
 
 
-    def test_data_pipelines(self):
-
-        fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
-        
-        dps = fc.list_data_pipelines(workspace_id)
-        dp_names = [dp.display_name for dp in dps]
-        self.assertGreater(len(dps), 0)
-        self.assertIn("pipeline1", dp_names)
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_name="pipeline1")
-        self.assertIsNotNone(dp.id)
-        self.assertIsNotNone(dp.definition)
-        self.assertEqual(dp.display_name, "pipeline1")
-
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline2")
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, "pipeline2")
-        self.assertEqual(dp.id, dp2.id)
-
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline1")
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, "pipeline1")
-        self.assertEqual(dp.id, dp2.id)
-        # status_code = fc.delete_data_pipeline(workspace_id, dp.id)
-        # self.assertEqual(status_code, 200)
-
-    def test_eventstreams(self):
-
+    def test_eventhouses(self):
+            
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        es_name = "es" + datetime_str
-
-        eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
-        self.assertEqual(eventstream.display_name, es_name)
-
-        eventstreams = fc.list_eventstreams(workspace_id)
-        eventstream_names = [es.display_name for es in eventstreams]
-        self.assertGreater(len(eventstreams), 0)
-        self.assertIn(es_name, eventstream_names)
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name="eventhouse1")
+        self.assertEqual(eventhouse1.display_name, "eventhouse1")
         
-        es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
-        self.assertIsNotNone(es.id)
-        self.assertEqual(es.display_name, es_name)
+        eventhouses = fc.list_eventhouses(workspace_id)
+        eventhouse_names = [eh.display_name for eh in eventhouses]
+        self.assertGreater(len(eventhouses), 0)
+        self.assertIn("eventhouse1", eventhouse_names)
 
-        es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2")
+        eh = fc.get_eventhouse(workspace_id, eventhouse_name="eventhouse1")
+        self.assertIsNotNone(eh.id)
+        self.assertEqual(eh.display_name, "eventhouse1")
 
-        es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
-        self.assertEqual(es.display_name, f"{es_name}2")
-        self.assertEqual(es.id, es2.id)
+        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name="eventhouse2")
 
-        status_code = fc.delete_eventstream(workspace_id, es.id)
-        self.assertEqual(status_code, 200)
-
-    def test_kql_database(self):
-
-        fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
-
-        kql_databases = fc.list_kql_databases(workspace_id)
-        kql_database_names = [kqldb.display_name for kqldb in kql_databases]
-        self.assertGreater(len(kql_databases), 0)
-        self.assertIn("kqldatabase1", kql_database_names)
+        eh = fc.get_eventhouse(workspace_id, eventhouse_id=eh.id)
+        self.assertEqual(eh.display_name, "eventhouse2")
+        self.assertEqual(eh.id, eh2.id)
 
-        kqldb = fc.get_kql_database(workspace_id, kql_database_name="kqldatabase1")
-        self.assertIsNotNone(kqldb.id)
-        self.assertEqual(kqldb.display_name, "kqldatabase1")
-
-        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldb2")
-
-        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
-        self.assertEqual(kqldb.display_name, "kqldb2")
-        self.assertEqual(kqldb.id, kqldb2.id)
-        
-        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldatabase1")
+        status_code = fc.delete_eventhouse(workspace_id, eh.id)
+        self.assertEqual(status_code, 200)
 
-        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
-        self.assertEqual(kqldb.display_name, "kqldatabase1")
-        self.assertEqual(kqldb.id, kqldb2.id)
-        # status_code = fc.delete_kql_database(workspace_id, kqldb.id)
-        # self.assertEqual(status_code, 200)
 
     def test_kql_querysets(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         kql_queryset_name = "kqlqueryset1"
 
@@ -273,8 +231,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_ml_experiments(self):
             
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         ml_experiment = fc.create_ml_experiment(workspace_id, display_name="mlexperiment1")
         self.assertEqual(ml_experiment.display_name, "mlexperiment1")
@@ -300,8 +257,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_ml_models(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         model_name = "mlm" + datetime_str
 
@@ -329,14 +285,17 @@ class TestFabricClientCore(unittest.TestCase):
     def test_notebooks(self):
             
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         notebook_name = "notebook125"
 
         notebook_w_content = fc.get_notebook(workspace_id, notebook_name="HelloWorld")
-        definition = notebook_w_content.definition
 
+        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)
@@ -364,13 +323,18 @@ class TestFabricClientCore(unittest.TestCase):
     def test_reports(self):
                 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         report_name = "report1234"
 
         report_w_content = fc.get_report(workspace_id, report_name="HelloWorldReport")
-        definition = report_w_content.definition
+
+        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)
@@ -392,13 +356,17 @@ class TestFabricClientCore(unittest.TestCase):
     def test_semantic_models(self):
                     
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         semantic_model_name = "semanticmodel1234"
 
         semantic_model_w_content = fc.get_semantic_model(workspace_id, semantic_model_name="Table")
-        definition = semantic_model_w_content.definition
+
+        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)
@@ -421,14 +389,19 @@ class TestFabricClientCore(unittest.TestCase):
     def test_spark_job_definitions(self):
         
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         spark_job_definition_name = f"sjd{datetime_str}"
 
         spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
-        definition = spark_job_definition_w_content.definition
+
+        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
         spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
         fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
         spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)
@@ -454,8 +427,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_warehouses(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         warehouse1 = f"wh{datetime_str}"

msfabricpysdkcore/tests/test_jobs.py

@@ -1,5 +1,9 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 class TestFabricClientCore(unittest.TestCase):