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

msfabricpysdkcore/__init__.py

@@ -1,2 +1,3 @@
 from .coreapi import FabricClientCore
-from .adminapi import FabricClientAdmin
+from .adminapi import FabricClientAdmin
+from .fabric_azure_client import FabricAzureClient

msfabricpysdkcore/admin_item.py

@@ -74,7 +74,7 @@ class AdminItem:
             description = item_dict.get('description', None),
             last_updated_date = item_dict['lastUpdatedDate'],
             capacity_id = item_dict['capacityId'],
-            creator_principal = item_dict['creatorPrincipal'],
+            creator_principal = item_dict.get('creatorPrincipal', None),
             admin_client = admin_client
         )
             

msfabricpysdkcore/adminapi.py

@@ -10,7 +10,9 @@ class FabricClientAdmin(FabricClient):
 
     def __init__(self, tenant_id = None, client_id = None, client_secret = None) -> None:
         """Initialize FabricClientAdmin object"""
-        super().__init__(tenant_id, client_id, client_secret)
+        super().__init__(scope="https://api.fabric.microsoft.com/.default", 
+                         tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
+
 
     def long_running_operation(self, response_headers):
         """Check the status of a long running operation"""

msfabricpysdkcore/auth.py

@@ -8,6 +8,9 @@ except ImportError:
 class FabricAuth():
     """FabricAuth class to interact with Entra ID"""
 
+    def __init__(self, scope):
+        self.scope = scope
+
     @abstractmethod
     def get_token(self):
         """Get token from Azure AD"""
@@ -26,20 +29,23 @@ class FabricAuth():
 class FabricAuthClient(FabricAuth):
     """FabricAuthClient class to interact with Entra ID"""
 
-    def __init__(self, silent = False):
+    def __init__(self, scope, silent = False):
+        super().__init__(scope)
         if not silent:
             print("Using Azure CLI for authentication")
         self.auth = AzureCliCredential()
 
     def get_token(self):
         """Get token from Azure AD"""
-        token = self.auth.get_token("https://api.fabric.microsoft.com/.default")
+        token = self.auth.get_token(self.scope)
         return token.token
 
 class FabricServicePrincipal(FabricAuth):
     """FabricServicePrincipal class to interact with Entra ID"""
 
-    def __init__(self, tenant_id, client_id, client_secret, silent = False):
+    def __init__(self, tenant_id, client_id, client_secret, scope, silent = False):
+        super().__init__(scope)
+
         if not silent:
             print("Using Service Principal for authentication")
 
@@ -47,8 +53,6 @@ class FabricServicePrincipal(FabricAuth):
         self.client_id = client_id
         self.client_secret = client_secret
 
-        self.scope = "https://api.fabric.microsoft.com/.default"
-
     
     def get_token(self):
         """Get token from Azure AD"""
@@ -67,7 +71,7 @@ class FabricServicePrincipal(FabricAuth):
 class FabricSparkUtilsAuthentication(FabricAuth):
     """FabricSparkUtilsAuthentication class to interact with Entra ID"""
 
-    def __init__(self, silent = False):
+    def __init__(self, scope, silent = False):
         mssparkutils.credentials.getToken("pbi")
         if not silent:
             print("Using Synapse Spark Utils for authentication")

msfabricpysdkcore/client.py

@@ -9,26 +9,29 @@ from msfabricpysdkcore.auth import FabricAuthClient, FabricServicePrincipal, Fab
 class FabricClient():
     """FabricClient class to interact with Fabric API"""
 
-    def __init__(self, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
+    def __init__(self, scope, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
         """Initialize FabricClient object"""
         self.tenant_id = tenant_id if tenant_id else os.getenv("FABRIC_TENANT_ID")
         self.client_id = client_id if client_id else os.getenv("FABRIC_CLIENT_ID")
         self.client_secret = client_secret if client_secret else os.getenv("FABRIC_CLIENT_SECRET")
-
-        self.scope = "https://api.fabric.microsoft.com/.default"
+        self.scope = scope
+        #self.scope = "https://api.fabric.microsoft.com/.default"
 
         if self.client_id is None or self.client_secret is None or self.tenant_id is None:
             try:
-                self.auth = FabricSparkUtilsAuthentication(silent=silent)
+                self.auth = FabricSparkUtilsAuthentication(self.scope, silent=silent)
             except:
-                self.auth = FabricAuthClient(silent=silent)
+                self.auth = FabricAuthClient(self.scope, silent=silent)
         else:
-            self.auth = FabricServicePrincipal(tenant_id = self.tenant_id,
+            self.auth = FabricServicePrincipal(scope= self.scope,
+                                               tenant_id = self.tenant_id,
                                                client_id = self.client_id, 
                                                client_secret = self.client_secret,
                                                silent=silent)
             
-
+    def get_token(self):
+        """Get token from Entra"""
+        return self.auth.get_token()
 
     def calling_routine(self, url, operation, body = None, headers=None, file_path = None, response_codes = [200], error_message = "Error",
                         continue_on_error_code = False, return_format = "value_json", paging = False,

msfabricpysdkcore/coreapi.py

@@ -8,7 +8,10 @@ class FabricClientCore(FabricClient):
 
     def __init__(self, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
         """Initialize FabricClientCore object"""
-        super().__init__(tenant_id, client_id, client_secret, silent=silent)
+        super().__init__(scope="https://api.fabric.microsoft.com/.default", 
+                         tenant_id=tenant_id,
+                         client_id=client_id,
+                         client_secret=client_secret,  silent=silent)
 
     def long_running_operation(self, response_headers):
         """Check the status of a long running operation"""

msfabricpysdkcore/fabric_azure_capacity.py

@@ -0,0 +1,77 @@
+import json 
+
+from msfabricpysdkcore.fabric_azure_client import FabricAzureClient
+
+class FabricAzureCapacity:
+    """Class to represent a item in Microsoft Fabric"""
+
+    def __init__(self, id, name, subscription_id, resource_group_name, type, location, properties, sku, azure_client: FabricAzureClient, tags=None) -> None:
+        
+        self.id = id
+        self.name = name
+        self.subscription_id = subscription_id
+        self.resource_group_name = resource_group_name
+        self.type = type
+        self.location = location
+        self.properties = properties
+        self.sku = sku
+        self.tags = tags
+
+        self.azure_client = azure_client
+
+    def __str__(self) -> str:
+        """Return a string representation of the fabric azure capacity object"""
+        dict_ = {
+            'id': self.id,
+            'name': self.name,
+            'subscription_id': self.subscription_id,
+            'resource_group_name': self.resource_group_name,
+            'type': self.type,
+            'location': self.location,
+            'properties': self.properties,
+            'sku': self.sku,
+            'tags': self.tags
+        }
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def from_dict(dict, azure_client):
+        """Create FabricAzureCapacity object from dictionary"""
+            
+        return FabricAzureCapacity(id=dict['id'], name=dict['name'], subscription_id=dict['subscription_id'],
+                                   resource_group_name=dict['resource_group_name'],
+                                   type=dict['type'],
+                                   location=dict['location'],
+                                   properties=dict['properties'], sku=dict['sku'],
+                                   tags=dict.get('tags', None), azure_client=azure_client)
+    
+    # Delete
+
+    def delete(self):
+        """Delete the capacity"""
+
+        return self.azure_client.delete_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Resume
+
+    def resume(self):
+        """Resume the capacity"""
+
+        return self.azure_client.resume_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Suspend
+
+    def suspend(self):
+        """Suspend the capacity"""
+
+        return self.azure_client.suspend_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Update
+
+    def update(self, properties_administration=None, sku=None, tags=None):
+        """Update the capacity"""
+
+        return self.azure_client.update_capacity(self.subscription_id, self.resource_group_name, self.name, properties_administration=properties_administration, sku=sku, tags=tags)
+

msfabricpysdkcore/fabric_azure_client.py

@@ -0,0 +1,228 @@
+from msfabricpysdkcore.client import FabricClient
+
+
+class FabricAzureClient(FabricClient):
+
+    def __init__(self, tenant_id=None, client_id=None, client_secret=None, silent=False) -> None:
+        super().__init__(scope = "https://management.azure.com/",
+                         tenant_id = tenant_id,
+                         client_id = client_id,
+                         client_secret = client_secret,
+                         silent = silent)
+
+
+    def check_name_availability(self, subscription_id, location, name, type = "Microsoft.Fabric/capacities"):
+        """Check name availability
+        Args:
+            subscription_id (str): The subscription ID
+            location (str): The location
+            name (str): The name
+            type (str): The type
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/locations/{location}/checkNameAvailability?api-version=2023-11-01"
+
+        body = {
+            "name": name,
+            "type": type
+        }
+
+        response = self.calling_routine(url=url, operation="POST", body=body, response_codes=[200], return_format="json", error_message="Failed to check name availability")
+        return response
+
+    def create_or_update_capacity(self, subscription_id, resource_group_name, capacity_name, location, properties_administration, sku, tags = None):
+        """Create or update capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+            location (str): The location
+            properties_administration (dict): The administration properties
+            sku (dict): The sku
+            tags (dict): The tags
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        if sku and "name" in sku:
+            sku = sku["name"]
+
+        body = {
+            "location": location,
+            "properties": {
+                "administration": properties_administration
+            },
+            "sku": {"name": sku,
+                    "tier": "Fabric"}
+        }
+
+        if tags is not None:
+            body["tags"] = tags
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="PUT", body=body, response_codes=[200, 201], return_format="json", error_message="Failed to create or update capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)
+
+
+    def delete_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Delete capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="DELETE", response_codes=[202], return_format="response", error_message="Failed to delete capacity")
+        return response
+
+
+    def get_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Get capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="json", error_message="Failed to get capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)
+
+    def list_by_resource_group(self, subscription_id, resource_group_name):
+        """List capacities by resource group
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list capacities by resource group")
+        return response
+
+
+    def list_by_subscription(self, subscription_id):
+        """List capacities by subscription
+        Args:
+            subscription_id (str): The subscription ID
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list capacities by subscription")
+        return response
+
+    def list_skus(self, subscription_id):
+        """List skus
+        Args:
+            subscription_id (str): The subscription ID
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list skus")
+        return response
+    
+    def list_skus_for_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """List skus for capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/skus?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list skus for capacity")
+        return response
+
+    def resume_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Resume capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/resume?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="POST", response_codes=[202], return_format="response", error_message="Failed to resume capacity")
+        return response
+
+    def suspend_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Suspend capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/suspend?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="POST", response_codes=[202], return_format="response", error_message="Failed to suspend capacity")
+        return response
+    
+    def update_capacity(self, subscription_id, resource_group_name, capacity_name, properties_administration = None, sku = None, tags = None):
+        """Update capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+            body (dict): The body of the request
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        body = {}
+        if sku and "name" in sku:
+            sku = sku["name"]
+
+        if properties_administration is not None:
+            body["properties"] = {}
+            body["properties"]["administration"] = properties_administration
+
+        if sku is not None:
+            body["sku"] = {"name": sku,
+                           "tier": "Fabric"}
+        
+        if tags is not None:
+            body["tags"] = tags
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="PATCH", body=body, response_codes=[200, 202],
+                                        return_format="json", error_message="Failed to update capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)

msfabricpysdkcore/tests/test_admin_apis.py

@@ -13,12 +13,12 @@ class TestFabricClientCore(unittest.TestCase):
     def test_admin_api(self):
         fca = self.fca
 
-        user_id = 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2'
+        user_id = '1dc64c6e-7a10-4ea9-8488-85d0739a377d'
 
         # List workspaces
-        ws = fca.list_workspaces(name="testworkspace")[0]
+        ws = fca.list_workspaces(name="testitems")[0]
 
-        self.assertEqual(ws.name, "testworkspace")
+        self.assertEqual(ws.name, "testitems")
 
         # Get workspace
         ws_clone = fca.get_workspace(workspace_id=ws.id)
@@ -71,8 +71,8 @@ class TestFabricClientCore(unittest.TestCase):
 
         fca = self.fca
 
-        items = [{"id": "d417b834-d381-454c-9cf0-c491f69508de", "type": "Lakehouse"}]
-        label_id = "defa4170-0d19-0005-000a-bc88714345d2"
+        items = [{"id": "9cdd3192-bcd0-4cbe-b945-29f5964e7ab7", "type": "Lakehouse"}]
+        label_id = "defa4170-0d19-0005-0007-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)
@@ -83,17 +83,16 @@ class TestFabricClientCore(unittest.TestCase):
         fca = self.fca
 
         data_shares = fca.list_external_data_shares()
-        ws = fca.list_workspaces(name="testworkspace")[0]
+        ws_id = "63aa9e13-4912-4abe-9156-8a56e565b7a3"
 
-        data_shares = [d for d in data_shares if d['workspaceId'] == ws.id]
+        data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
 
         self.assertGreater(len(data_shares), 0)
         fca.revoke_external_data_share(external_data_share_id = data_shares[0]['id'], 
                                        item_id = data_shares[0]['itemId'], 
                                        workspace_id = data_shares[0]['workspaceId'])
         data_shares = fca.list_external_data_shares()
-        ws = fca.list_workspaces(name="testworkspace")[0]
 
-        data_shares = [d for d in data_shares if d['workspaceId'] == ws.id]
+        data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
 
         self.assertEqual(data_shares[0]['status'], 'Revoked')

msfabricpysdkcore/tests/test_datapipelines.py

@@ -16,7 +16,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_data_pipelines(self):
 
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         pipeline_name = f"pipeline_{datetime_str}"
 

msfabricpysdkcore/tests/test_domains.py

@@ -18,7 +18,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         ws = fcc.get_workspace_by_name("sdktestdomains")
         cap = fcc.get_capacity(capacity_id=ws.capacity_id)
-        principal = {'id': 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2',  'type': 'User'}
+        principal = {'id': '1dc64c6e-7a10-4ea9-8488-85d0739a377d',  'type': 'User'}
 
         # Delete if exists
         try:
@@ -104,7 +104,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Role assignments bulk assign
         
-        principal_2 = {'id': '6edbc444-16cd-43f4-ae48-cbe734b89657', 'type': 'User'}
+        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)

msfabricpysdkcore/tests/test_environments.py

@@ -14,7 +14,7 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environments_crudl(self):
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
 
         env_name = "env" + datetime_str
@@ -41,8 +41,8 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environment_details(self):
         fc = FabricClientCore()
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-        environment_id = 'fae6d1a7-d671-4091-89b1-f42626deb56f'
+        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)
@@ -67,13 +67,13 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_environment_spark_libraries(self):
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-        environment_id = 'fae6d1a7-d671-4091-89b1-f42626deb56f'
+        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.0.13-py3-none-any.whl', resp['customLibraries']['wheelFiles'])
+        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)

msfabricpysdkcore/tests/test_evenhouses.py

@@ -12,7 +12,6 @@ class TestFabricClientCore(unittest.TestCase):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         #load_dotenv()
         self.fc = FabricClientCore()
-        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         self.item_name = "testitem" + datetime_str
@@ -23,7 +22,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_eventhouses(self):
             
         fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         eventhouse_name = "evh" + datetime_str
         eventhouse1 = fc.create_eventhouse(workspace_id, display_name=eventhouse_name)

msfabricpysdkcore/tests/test_evenstreams.py

@@ -15,30 +15,30 @@ class TestFabricClientCore(unittest.TestCase):
 
     def test_eventstreams(self):
 
-            fc = self.fc
-            workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        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
+        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)
+        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)
+        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)
+        
+        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)
+        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)
+        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)
+        status_code = fc.delete_eventstream(workspace_id, es.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_external_data_shares.py

@@ -14,13 +14,13 @@ class TestFabricClientCore(unittest.TestCase):
         
         fc = self.fc
 
-        workspace_id = 'c3352d34-0b54-40f0-b204-cc964b1beb8d'
-        item_id = 'e2c09c89-bf97-4f71-bdeb-36338795ec36'
+        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
+        item_id = "148ef579-4a5d-4048-8a48-0a703c5e3a1a"
 
         recipient = {
             "userPrincipalName": "lisa4@fabrikam.com"
         }
-        paths=["Files/external"]
+        paths=["Files/to_share"]
 
         resp = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
         self.assertIsNotNone(resp)