msfabricpysdkcore 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

msfabricpysdkcore/tests/test_environments.py

@@ -10,39 +10,56 @@ class TestFabricClientCore(unittest.TestCase):
 
     def __init__(self, *args, **kwargs):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
-        #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = "d8a5abe0-9eed-406d-ab46-343bc57ddbe5"
 
-        
-    def test_environments(self):
+    def test_environments_crudl(self):
         fc = self.fc
-        workspace_id = self.workspace_id
-
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        envname = "testitem" + datetime_str
-        env1 = fc.create_environment(workspace_id, envname, "testenv description")
-
-        env2 = fc.get_environment(workspace_id, environment_name=envname)
-
-        self.assertEqual(env1.id, env2.id)
-
-        env_list = fc.list_environments(workspace_id, with_properties=True)
-        env_names = [env.display_name for env in env_list]
-
-        self.assertIn(envname, env_names)
-
-        env3 = fc.update_environment(workspace_id, env1.id, envname + "name", "testenv description updated")
-
-        env4 = fc.get_environment(workspace_id, environment_name=env3.display_name)
-
-        self.assertEqual(env1.id, env4.id)
-
-        fc.delete_environment(workspace_id, env4.id)
-
-        env_list = fc.list_environments(workspace_id, with_properties=True)
-        env_names = [env.display_name for env in env_list]
-
-        self.assertNotIn(env4.display_name, env_names)
 
-        
+        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

@@ -30,7 +30,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         status_code = self.fc.git_connect(workspace_id=ws2.id, git_provider_details=git_provider_details)
 
-        self.assertEqual(status_code, 204)
+        self.assertEqual(status_code, 200)
 
         initialization_strategy = "PreferWorkspace"
 
@@ -56,7 +56,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         status_code = self.fc.git_disconnect(workspace_id=ws2.id)
 
-        self.assertEqual(status_code, 204)
+        self.assertEqual(status_code, 200)
 
         ws2.delete()
 

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -78,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]
@@ -144,8 +143,7 @@ class TestFabricClientCore(unittest.TestCase):
         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)
@@ -171,116 +169,38 @@ 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")
-
-        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)
-
-    def test_eventstreams(self):
-
+    def test_eventhouses(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")
-        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)
-
+        eventhouse_name = "evh" + datetime_str
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name=eventhouse_name)
+        self.assertEqual(eventhouse1.display_name, eventhouse_name)
         
-        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)
+        eventhouses = fc.list_eventhouses(workspace_id)
+        eventhouse_names = [eh.display_name for eh in eventhouses]
+        self.assertGreater(len(eventhouses), 0)
+        self.assertIn(eventhouse_name, eventhouse_names)
+
+        eh = fc.get_eventhouse(workspace_id, eventhouse_name=eventhouse_name)
+        self.assertIsNotNone(eh.id)
+        self.assertEqual(eh.display_name, eventhouse_name)
+        new_display_name = eventhouse_name + "2"
+        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name=new_display_name)
+
+        eh = fc.get_eventhouse(workspace_id, eventhouse_id=eh.id)
+        self.assertEqual(eh.display_name, new_display_name)
+        self.assertEqual(eh.id, eh2.id)
+
+        status_code = fc.delete_eventhouse(workspace_id, eh.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)
-
-        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)
-        
-        # retry 3 times
-        i = 0
-        while i < 3:
-            try:
-                kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldatabase1")
-                break
-            except Exception as e:
-                sleep(10)
-                i += 1
-            
-        
-
-        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"
 
@@ -312,8 +232,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")
@@ -339,8 +258,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
 
@@ -356,11 +274,11 @@ class TestFabricClientCore(unittest.TestCase):
         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)
+        mlm2 = fc.update_ml_model(workspace_id=workspace_id,ml_model_id= mlm.id,  description=model_name)
 
-        # mlm = fc.get_ml_model(workspace_id, ml_model_id=mlm.id)
-        # self.assertEqual(mlm.description, model_name)
-        # self.assertEqual(mlm.id, mlm2.id)
+        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)
@@ -368,8 +286,7 @@ 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"
 
@@ -407,8 +324,7 @@ 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"
 
@@ -441,8 +357,7 @@ 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"
 
@@ -471,51 +386,10 @@ class TestFabricClientCore(unittest.TestCase):
         status_code = fc.delete_semantic_model(workspace_id, sm.id)
         self.assertEqual(status_code, 200)
 
-
-    def test_spark_job_definitions(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")
-        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 = 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)
-        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
-        self.assertIsNotNone(spark_job_definition.definition)
-
-        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
-        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
-        self.assertGreater(len(spark_job_definitions), 0)
-        self.assertIn(spark_job_definition_name, spark_job_definition_names)
-
-        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
-        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.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
-        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
-
-        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
-        self.assertEqual(status_code, 200)
-
     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_kqldatabases.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_kql_database(self):
+
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        evenhouse_id = "14822d45-5460-4efa-9b30-8628510a9197"
+
+        creation_payload = {"databaseType" : "ReadWrite",
+                            "parentEventhouseItemId" : evenhouse_id}
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        kqldb_name = "kql" + datetime_str
+        kqldb = fc.create_kql_database(workspace_id = workspace_id, display_name=kqldb_name,
+                                    creation_payload=creation_payload)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+
+        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(kqldb_name, kql_database_names)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_name=kqldb_name)
+        self.assertIsNotNone(kqldb.id)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+        
+        new_name = kqldb_name+"2"
+        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name=new_name)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
+        self.assertEqual(kqldb.display_name, new_name)
+        self.assertEqual(kqldb.id, kqldb2.id)
+        
+        status_code = fc.delete_kql_database(workspace_id, kqldb.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_sparkjobdefinition.py

@@ -0,0 +1,55 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+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_spark_job_definitions(self):
+        
+        fc = self.fc
+        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")
+
+        result = fc.run_on_demand_spark_job_definition(workspace_id=workspace_id, 
+                                                        spark_job_definition_id=spark_job_definition_w_content.id,
+                                                        job_type="sparkjob")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.job_type, "sparkjob")
+        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)
+        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
+        self.assertIsNotNone(spark_job_definition.definition)
+
+        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
+        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
+        self.assertGreater(len(spark_job_definitions), 0)
+        self.assertIn(spark_job_definition_name, spark_job_definition_names)
+
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
+        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.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
+        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
+
+        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
+        self.assertEqual(status_code, 200)