msfabricpysdkcore 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

msfabricpysdkcore/tests/test_datapipelines.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()
+
+    def test_data_pipelines(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        pipeline_name = f"pipeline_{datetime_str}"
+
+        dp = fc.create_data_pipeline(workspace_id, display_name=pipeline_name, description="asda")
+        dp.update_definition(dp.definition)
+
+        dps = fc.list_data_pipelines(workspace_id)
+        dp_names = [dp.display_name for dp in dps]
+        self.assertGreater(len(dps), 0)
+        self.assertIn(pipeline_name, dp_names)
+
+        self.assertEqual(dp.display_name, pipeline_name)
+        pipeline_name2 = f"pipeline_{datetime_str}_2"
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name2, return_item=True)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, pipeline_name2)
+        self.assertEqual(dp.id, dp2.id)
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name, return_item=True)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, pipeline_name)
+        self.assertEqual(dp.id, dp2.id)
+        status_code = fc.delete_data_pipeline(workspace_id, dp.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -0,0 +1,63 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+
+
+    def test_spark_workspace_custom_pools(self):
+        fc = self.fc
+
+        dep_pipes = fc.list_deployment_pipelines()
+
+        self.assertGreater(len(dep_pipes), 0)
+
+        self.assertIn("sdkpipe", [pipe.display_name for pipe in dep_pipes])
+
+        for pipe in dep_pipes:
+            if pipe.display_name == 'sdkpipe':
+                pipe_id = pipe.id
+                break
+
+        pipe = fc.get_deployment_pipeline(pipe_id)
+
+        self.assertEqual(pipe.display_name, 'sdkpipe')
+        self.assertEqual(pipe.id, pipe_id)
+
+        stages = fc.list_deployment_pipeline_stages(pipe_id)
+
+        self.assertGreater(len(stages), 0)
+        names = [stage.display_name for stage in stages]
+        self.assertIn("Development", names)
+        self.assertIn("Production", names)
+
+        dev_stage = [stage for stage in stages if stage.display_name == "Development"][0]
+        prod_stage = [stage for stage in stages if stage.display_name == "Production"][0]
+
+        items = fc.list_deployment_pipeline_stages_items(deployment_pipeline_id=pipe_id, stage_id=dev_stage.id)
+        
+        self.assertGreater(len(items), 0)
+        self.assertIn("cicdlakehouse", [item["itemDisplayName"] for item in items])
+       
+        items = [item for item in dev_stage.list_items() if item["itemDisplayName"] == 'cicdlakehouse']
+        item = items[0]
+        item = {"sourceItemId": item["itemId"],
+                "itemType": item["itemType"]}
+        items = [item]
+
+        response = fc.deploy_stage_content(deployment_pipeline_id=pipe_id, source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+
+        self.assertEqual(response["status"], "Succeeded")
+
+        
+
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -0,0 +1,126 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
+
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+
+                  
+    def test_domains(self):
+        fcc = FabricClientCore()
+        fca = FabricClientAdmin()
+
+        ws = fcc.get_workspace_by_name("sdktestdomains")
+        cap = fcc.get_capacity(capacity_id=ws.capacity_id)
+        principal = {'id': '1dc64c6e-7a10-4ea9-8488-85d0739a377d',  'type': 'User'}
+
+        # Delete if exists
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains")
+            domain.delete()
+        except:
+            pass
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains2")
+            domain.delete()
+        except:
+            pass
+
+        # Create domain
+        domain_name = "sdktestdomains" + datetime.now().strftime("%Y%m%d%H%M%S")
+        domain = fca.create_domain(display_name=domain_name)
+        self.assertIsNotNone(domain.id)
+        self.assertEqual(domain.display_name, domain_name)
+
+        # Get domain by name
+        domain_clone = fca.get_domain_by_name(domain_name)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # Get domain by id
+        domain_clone = fca.get_domain_by_id(domain.id)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # List domains
+        domains = fca.list_domains()
+        self.assertGreater(len(domains), 0)
+        domains_ids = [d.id for d in domains]
+        self.assertIn(domain.id, domains_ids)
+
+        # Update domain
+        domain_new_name = f"{domain_name}2"
+        domain_clone = fca.update_domain(domain.id, display_name=domain_new_name, return_item=True)
+        self.assertEqual(domain_clone.display_name, domain_new_name)
+
+        # Assign domain workspaces by Ids
+        status_code = fca.assign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        # List domain workspaces
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign domain workspaces by ids
+        status_code = fca.unassign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by capacities
+        status_code = fca.assign_domain_workspaces_by_capacities(domain.id, [cap.id])
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign all domain workspaces
+        status_code = fca.unassign_all_domain_workspaces(domain.id)
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by principals
+        status_code = fca.assign_domains_workspaces_by_principals(domain.id, [principal], wait_for_completion=True)
+
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Role assignments bulk assign
+        
+        principal_2 = {'id': 'e0505016-ef55-4ca7-b106-e085cc201823', 'type': 'User'}
+        principals = [principal, principal_2]
+
+        status_code = fca.role_assignments_bulk_assign(domain.id, "Contributors", principals)
+
+        self.assertEqual(status_code, 200)
+
+        # Role assignments bulk unassign
+        status_code = fca.role_assignments_bulk_unassign(domain.id, "Contributors", [principal_2])
+
+        self.assertEqual(status_code, 200)
+
+        # Delete domain
+        status_code = fca.delete_domain(domain.id)
+
+        self.assertEqual(status_code, 200)
+
+        domains = fca.list_domains()
+        domains_ids = [d.id for d in domains]
+        self.assertNotIn(domain.id, domains_ids)

msfabricpysdkcore/tests/test_environments.py

@@ -0,0 +1,114 @@
+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 = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        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, return_item=True)
+
+        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 = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
+        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)
+
+
+    def test_environment_spark_libraries(self):
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        environment_id = '5648be67-28fa-48b6-9d1f-3c87c3704d3c'
+
+        resp = fc.get_published_libraries(workspace_id, environment_id)
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertIn('msfabricpysdkcore-0.1.1-py3-none-any.whl', resp['customLibraries']['wheelFiles'])
+
+        resp = fc.upload_staging_library(workspace_id, environment_id, 'dummy.whl')
+        self.assertEqual(resp.status_code, 200)
+        
+        resp = fc.get_staging_libraries(workspace_id, environment_id)
+
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertIn('dummy.whl', resp['customLibraries']['wheelFiles'])
+        self.assertIn('staging.whl', resp['customLibraries']['wheelFiles'])
+
+        
+        resp = fc.publish_environment(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'].lower(), 'running')
+
+        
+        resp = fc.cancel_publish(workspace_id, environment_id)
+        self.assertIn('publishDetails', resp)
+        self.assertIn('state', resp['publishDetails'])
+        self.assertEqual(resp['publishDetails']['state'].lower(), 'cancelled')
+
+        resp = fc.delete_staging_library(workspace_id, environment_id, 'dummy.whl')
+        self.assertEqual(resp.status_code, 200)
+
+        resp = fc.get_staging_libraries(workspace_id, environment_id)
+
+        self.assertIn('customLibraries', resp)
+        self.assertIn('wheelFiles', resp['customLibraries'])
+        self.assertNotIn('dummy.whl', resp['customLibraries']['wheelFiles'])
+        self.assertIn('staging.whl', resp['customLibraries']['wheelFiles'])
+
+
+        
+
+
+

msfabricpysdkcore/tests/test_evenhouses.py

@@ -0,0 +1,56 @@
+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_eventhouses(self):
+            
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        eventhouse_name = "evh" + datetime_str
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name=eventhouse_name)
+        self.assertEqual(eventhouse1.display_name, eventhouse_name)
+        
+        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, return_item=True)
+
+        definition = fc.get_eventhouse_definition(workspace_id, eventhouse_id=eh.id)
+       
+        self.assertIn("definition", definition)
+        self.assertIn("parts", definition["definition"])
+        self.assertGreaterEqual(len(definition["definition"]["parts"]), 2)
+
+        response = fc.update_eventhouse_definition(workspace_id, eventhouse_id=eh.id, definition=definition["definition"])
+        self.assertIn(response.status_code, [200, 202])
+
+        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)

msfabricpysdkcore/tests/test_evenstreams.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()
+
+    def test_eventstreams(self):
+
+        fc = self.fc
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+
+        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", return_item=True)
+
+        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)
+
+        response = fc.update_eventstream_definition(workspace_id, eventstream_id=es.id, definition=es.definition)
+        self.assertIn(response.status_code, [200, 202])
+
+        definition = fc.get_eventstream_definition(workspace_id, eventstream_id=es.id)
+        self.assertIn("definition", definition)
+        self.assertIn("parts", definition["definition"])
+        self.assertGreaterEqual(len(definition["definition"]["parts"]), 3)
+
+        status_code = fc.delete_eventstream(workspace_id, es.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_external_data_shares.py

@@ -0,0 +1,51 @@
+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_external_data_shares(self):
+        
+        fc = self.fc
+
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        item_id = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
+
+        recipient = {
+            "userPrincipalName": "lisa4@fabrikam.com"
+        }
+        paths=["Files/to_share"]
+
+        resp = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
+        self.assertIsNotNone(resp)
+        self.assertIn('id', resp)
+
+
+        get = fc.get_external_data_share(workspace_id, item_id, resp['id'])
+        self.assertIsNotNone(get)
+        self.assertEqual(get['id'], resp['id'])
+
+
+        resp = fc.list_external_data_shares_in_item(workspace_id, item_id)
+        self.assertGreater(len(resp), 0)
+
+        data_share_ids = [ds['id'] for ds in resp]
+        self.assertIn(get['id'], data_share_ids)
+
+
+        resp = fc.revoke_external_data_share(workspace_id, item_id, get['id'])
+        self.assertEqual(resp, 200)
+
+        get2 = fc.get_external_data_share(workspace_id, item_id, get['id'])
+        self.assertIsNotNone(get2)
+        
+        self.assertEqual(get['id'], get2['id'])
+        self.assertEqual(get2['status'], 'Revoked')
+
+

msfabricpysdkcore/tests/test_fabric_azure_client.py

@@ -0,0 +1,80 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from time import sleep
+from msfabricpysdkcore import FabricAzureClient
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fac = FabricAzureClient()
+
+    def test_azure_capacity(self):
+
+        fac = self.fac
+
+        subscription_id = "c77cc8fc-43bb-4d44-bdc5-6e20511ed2a8"
+        resource_group_name = "fabricdemo"
+        capacity_name = "westeuropeajrederer"
+        capacity_name_new = "westeuropeajrederer" + datetime.now().strftime("%Y%m%d%H%M%S")
+
+        resp = fac.check_name_availability(subscription_id, "westeurope", capacity_name_new)
+        self.assertIn('nameAvailable', resp)
+        self.assertEqual(resp['nameAvailable'], True)
+
+        resp = fac.create_or_update_capacity(subscription_id, resource_group_name, capacity_name_new, 
+                                            location="westeurope",
+                                            properties_administration={"members": ['admin@MngEnvMCAP065039.onmicrosoft.com']},
+                                            sku = "F2")
+        self.assertIsNotNone(resp.name)
+        self.assertEqual(resp.name, capacity_name_new)
+        
+        resp = fac.get_capacity(subscription_id, resource_group_name, capacity_name_new)
+        self.assertIsNotNone(resp.name)
+        self.assertEqual(resp.name, capacity_name_new)
+
+        sku = resp.sku['name']
+
+        sleep(60)
+        
+        resp = fac.delete_capacity(subscription_id, resource_group_name, capacity_name_new)
+        self.assertEqual(resp.status_code, 202)
+
+
+        resp = fac.list_by_resource_group(subscription_id, resource_group_name)
+        cap_names = [cap["name"] for cap in resp]
+        self.assertIn(capacity_name, cap_names)
+
+        
+
+        resp = fac.list_by_subscription(subscription_id)
+        cap_names = [cap["name"] for cap in resp]
+        self.assertIn(capacity_name, cap_names)
+
+
+        resp = fac.list_skus(subscription_id)
+        self.assertGreater(len(resp), 0, msg=f"No SKUs found: {resp}")
+
+
+        resp = fac.list_skus_for_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertGreater(len(resp), 0, msg=f"No SKUs found: {resp}")
+
+        resp = fac.resume_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertEqual(resp.status_code, 202)
+
+        sleep(60)
+        resp = fac.suspend_capacity(subscription_id, resource_group_name, capacity_name)
+        self.assertEqual(resp.status_code, 202)
+        sleep(60)
+
+        if sku != "F4":
+            resp = fac.update_capacity(subscription_id, resource_group_name, capacity_name, sku="F4")
+            self.assertEqual(resp.sku["name"], "F4")
+        else:
+            resp = fac.update_capacity(subscription_id, resource_group_name, capacity_name, sku="F2")
+            self.assertEqual(resp.sku["name"], "F2")