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

msfabricpysdkcore/tests/test_ml_experiments.py

@@ -1,47 +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()
-
-        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

@@ -1,47 +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()
-
-        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_mounted_adf.py

@@ -1,64 +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):
-
-class TestFabricClientCore(unittest.TestCase):
-
-    def __init__(self, *args, **kwargs):
-        super(TestFabricClientCore, self).__init__(*args, **kwargs)
-        #load_dotenv()
-        self.fc = FabricClientCore()
-
-   
-    def test_mounted_adf(self):
-
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-
-        definition = {'parts': [{'path': 'mountedDataFactory-content.json',
-                                'payload': 'ewogICJkYXRhRmFjdG9yeVJlc291cmNlSWQiOiAiL3N1YnNjcmlwdGlvbnMvYzc3Y2M4ZmMtNDNiYi00ZDQ0LWJkYzUtNmUyMDUxMWVkMmE4L3Jlc291cmNlR3JvdXBzL2ZhYnJpY2RlbW8vcHJvdmlkZXJzL01pY3Jvc29mdC5EYXRhRmFjdG9yeS9mYWN0b3JpZXMvZmFicmljYWRmMjAyNTAzMDYiCn0=',
-                                'payloadType': 'InlineBase64'},
-                                {'path': '.platform',
-                                'payload': 'ewogICIkc2NoZW1hIjogImh0dHBzOi8vZGV2ZWxvcGVyLm1pY3Jvc29mdC5jb20vanNvbi1zY2hlbWFzL2ZhYnJpYy9naXRJbnRlZ3JhdGlvbi9wbGF0Zm9ybVByb3BlcnRpZXMvMi4wLjAvc2NoZW1hLmpzb24iLAogICJtZXRhZGF0YSI6IHsKICAgICJ0eXBlIjogIk1vdW50ZWREYXRhRmFjdG9yeSIsCiAgICAiZGlzcGxheU5hbWUiOiAiZmFicmljYWRmMjAyNTAzMDYiCiAgfSwKICAiY29uZmlnIjogewogICAgInZlcnNpb24iOiAiMi4wIiwKICAgICJsb2dpY2FsSWQiOiAiMDAwMDAwMDAtMDAwMC0wMDAwLTAwMDAtMDAwMDAwMDAwMDAwIgogIH0KfQ==',
-                                'payloadType': 'InlineBase64'}]}
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-
-        mounted_adf_name = "mounted_adf" + datetime_str
-        mounted_adf = fc.create_mounted_data_factory(workspace_id,
-                                                     display_name=mounted_adf_name,
-                                                     definition=definition)
-
-        self.assertEqual(mounted_adf.display_name, mounted_adf_name)
-
-        mounted_adfs = fc.list_mounted_data_factories(workspace_id)
-        mounted_adf_names = [adf.display_name for adf in mounted_adfs]
-        self.assertGreater(len(mounted_adfs), 0)
-        self.assertIn(mounted_adf_name, mounted_adf_names)
-
-        adf = fc.get_mounted_data_factory(workspace_id, mounted_data_factory_name=mounted_adf_name)
-        self.assertIsNotNone(adf.id)
-        self.assertEqual(adf.display_name, mounted_adf_name)
-
-        adf2 = fc.update_mounted_data_factory(workspace_id, adf.id, display_name=f"{mounted_adf_name}2", return_item=True)
-
-        adf = fc.get_mounted_data_factory(workspace_id, mounted_data_factory_id=adf.id)
-        self.assertEqual(adf.display_name, f"{mounted_adf_name}2")
-        self.assertEqual(adf.id, adf2.id)
-
-        response = fc.update_mounted_data_factory_definition(workspace_id, mounted_data_factory_id=adf.id, definition=adf.definition)
-        self.assertIn(response.status_code, [200, 202])
-
-        definition = fc.get_mounted_data_factory_definition(workspace_id, mounted_data_factory_id=adf.id)
-        self.assertIn("definition", definition)
-        self.assertIn("parts", definition["definition"])
-        self.assertGreaterEqual(len(definition["definition"]["parts"]), 2)
-
-        status_code = fc.delete_mounted_data_factory(workspace_id, adf.id)
-        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_notebooks.py

@@ -1,57 +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()
-
-        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

@@ -1,63 +0,0 @@
-import unittest
-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_one_lake_data_access_security(self):
-
-        fc = self.fc
-
-        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)
-
-        roles = resp[0]
-        etag = resp[1]
-
-        role1 = roles[1]
-
-        self.assertIn('members', role1)
-        self.assertIn('fabricItemMembers', role1['members'])
-        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:
-            item_access = ['Read', 'Write', 'Execute']
-        else:
-            item_access.append('ReadAll')
-
-        role1["members"]["fabricItemMembers"][0]['itemAccess'] = item_access
-        roles[1] = role1
-
-        resp = fc.create_or_update_data_access_roles(workspace_id=workspace_id, 
-                                                     item_id=item_id, 
-                                                     data_access_roles=roles, 
-                                                     etag_match={"If-Match":etag})
-
-
-        resp = fc.list_data_access_roles(workspace_id=workspace_id, item_id=item_id)
-        self.assertEqual(len(resp), 2)
-
-        roles = resp[0]
-        etag = resp[1]
-
-        role1 = roles[1]
-
-        self.assertIn('members', role1)
-        self.assertIn('fabricItemMembers', role1['members'])
-        self.assertGreater(len(role1['members']['fabricItemMembers']), 0)
-        self.assertIn('itemAccess', role1['members']['fabricItemMembers'][0])
-
-        item_access = role1["members"]["fabricItemMembers"][0]['itemAccess']
-        self.assertNotEqual(item_access, item_access_old)

msfabricpysdkcore/tests/test_other_items.py

@@ -1,45 +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()
-
-        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_reflex.py

@@ -1,57 +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):
-
-class TestFabricClientCore(unittest.TestCase):
-
-    def __init__(self, *args, **kwargs):
-        super(TestFabricClientCore, self).__init__(*args, **kwargs)
-        #load_dotenv()
-        self.fc = FabricClientCore()
-
-   
-    def test_reflex(self):
-
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-
-        reflex_name = "reflex" + datetime_str
-
-        reflex = fc.create_reflex(workspace_id, display_name=reflex_name)
-        self.assertEqual(reflex.display_name, reflex_name)
-
-        reflexes = fc.list_reflexes(workspace_id)
-        reflex_names = [ref.display_name for ref in reflexes]
-        self.assertGreater(len(reflexes), 0)
-        self.assertIn(reflex_name, reflex_names)
-
-
-        ref = fc.get_reflex(workspace_id, reflex_name=reflex_name)
-        self.assertIsNotNone(ref.id)
-        self.assertEqual(ref.display_name, reflex_name)
-
-        ref2 = fc.update_reflex(workspace_id, ref.id, display_name=f"{reflex_name}2", return_item=True)
-
-        ref = fc.get_reflex(workspace_id, reflex_id=ref.id)
-        self.assertEqual(ref.display_name, f"{reflex_name}2")
-        self.assertEqual(ref.id, ref2.id)
-
-        response = fc.update_reflex_definition(workspace_id, reflex_id=ref.id, definition=ref.definition)
-        self.assertIn(response.status_code, [200, 202])
-
-        definition = fc.get_reflex_definition(workspace_id, reflex_id=ref.id)
-        self.assertIn("definition", definition)
-        self.assertIn("parts", definition["definition"])
-        self.assertGreaterEqual(len(definition["definition"]["parts"]), 2)
-
-        status_code = fc.delete_reflex(workspace_id, ref.id)
-        self.assertEqual(status_code, 200)
-

msfabricpysdkcore/tests/test_reports.py

@@ -1,56 +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()
-
-        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)
-
-        r2 = fc.update_report(workspace_id, r.id, display_name=f"{report_name}2", return_item=True)
-        self.assertEqual(r2.display_name, f"{report_name}2")
-        self.assertEqual(r2.id, r.id)
-
-        status_code = fc.delete_report(workspace_id, r.id)
-        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_semantic_model.py

@@ -1,56 +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()
-
-        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)
-
-        sm2 = fc.update_semantic_model(workspace_id, sm.id, display_name=f"u{semantic_model_name}", return_item=True)
-
-        sm2 = fc.get_semantic_model(workspace_id, semantic_model_id=sm2.id)
-
-        self.assertEqual(sm2.display_name, f"u{semantic_model_name}")
-
-        status_code = fc.delete_semantic_model(workspace_id, sm.id)
-        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_shortcuts.py

@@ -1,60 +0,0 @@
-import unittest
-from msfabricpysdkcore.coreapi import FabricClientCore
-from datetime import datetime
-from dotenv import load_dotenv
-
-load_dotenv()
-
-class TestFabricClientCore(unittest.TestCase):
-
-    def __init__(self, *args, **kwargs):
-        super(TestFabricClientCore, self).__init__(*args, **kwargs)
-        #load_dotenv()
-        self.fc = FabricClientCore()
-        self.workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-
-        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/to_share"
-        self.path_shortcut = "Files/shortcutfolder"
-
-        self.target = {'oneLake': {'itemId': self.lakehouse_target,
-                                   'path': self.path_target,        
-                                   'workspaceId': self.workspace_id}}
-
-    def test_shortcut_end_to_end(self):
-
-        item = self.fc.create_shortcut(workspace_id=self.workspace_id,
-                                       item_id=self.lakehouse_shortcut,
-                                       path=self.path_shortcut,
-                                       name=self.shortcutname,
-                                       target=self.target)
-        self.assertEqual(item.name, self.shortcutname)
-        self.assertEqual(item.path, self.path_shortcut)
-        self.assertIn("oneLake", item.target)
-
-        item = self.fc.get_shortcut(workspace_id=self.workspace_id,
-                                    item_id=self.lakehouse_shortcut,
-                                    path=self.path_shortcut,
-                                    name=self.shortcutname)
-        self.assertEqual(item.name, self.shortcutname)
-        self.assertEqual(item.path, self.path_shortcut)
-        self.assertIn("oneLake", item.target)
-
-        shortcuts = self.fc.list_shortcuts(workspace_id=self.workspace_id,
-                                          item_id=self.lakehouse_shortcut, parent_path="Files")
-        self.assertGreater(len(shortcuts), 0)
-
-
-        status_code = self.fc.delete_shortcut(workspace_id=self.workspace_id,
-                                             item_id=self.lakehouse_shortcut,
-                                             path=self.path_shortcut,
-                                             name=self.shortcutname)
-        
-        self.assertAlmostEqual(status_code, 200)
-
-if __name__ == "__main__":
-    unittest.main()

msfabricpysdkcore/tests/test_spark.py

@@ -1,91 +0,0 @@
-import unittest
-from msfabricpysdkcore.coreapi import FabricClientCore
-from dotenv import load_dotenv
-from datetime import datetime
-
-load_dotenv()
-
-
-class TestFabricClientCore(unittest.TestCase):
-
-    def __init__(self, *args, **kwargs):
-        super(TestFabricClientCore, self).__init__(*args, **kwargs)
-        #load_dotenv()
-        self.fc = FabricClientCore()
-
-
-    def test_spark_workspace_custom_pools(self):
-        fc = self.fc
-        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)
-        self.assertGreater(len(pools), 0)
-
-        pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
-
-        self.assertIn("pool1", [p.name for p in pools])
-        pool1 = [p for p in pools if p.name == "pool1"][0]
-
-        # Get
-
-        pool1_clone = fc.get_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool1.id)
-        self.assertEqual(pool1_clone.id, pool1.id)
-        # Create
-
-        pool2 = fc.create_workspace_custom_pool(workspace_id=workspace_id, 
-                                        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, 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},
-                                        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)
-        self.assertEqual(pool2_clone.auto_scale["maxNodeCount"], 7)
-
-        # Delete
-        status_code = fc.delete_workspace_custom_pool(workspace_id=workspace_id, pool_id=pool2.id)
-        self.assertEqual(status_code, 200)
-
-        pools = fc.list_workspace_custom_pools(workspace_id=workspace_id)
-        self.assertNotIn(pool_name, [p.name for p in pools])
-
-    def test_workspace_settings(self):
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-
-        # Get
-
-        settings = fc.get_spark_settings(workspace_id)
-        self.assertIn("automaticLog", settings)
-        
-        
-        orig_setting = settings["automaticLog"]["enabled"]
-        settings["automaticLog"]["enabled"] = not settings["automaticLog"]["enabled"]
-
-        # Update
-        settings = fc.update_spark_settings(workspace_id, automatic_log=settings["automaticLog"])
-        new_setting = settings["automaticLog"]["enabled"]
-        self.assertNotEqual(orig_setting, new_setting)
-        self.assertTrue(orig_setting or new_setting)
-        self.assertFalse(orig_setting and new_setting)
-
-        settings = fc.get_spark_settings(workspace_id)
-        checked_setting = settings["automaticLog"]["enabled"]
-        self.assertEqual(checked_setting, new_setting)
-
-
-if __name__ == "__main__":
-    unittest.main()
-