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

msfabricpysdkcore/long_running_operation.py

@@ -1,54 +1,24 @@
-import json 
-import requests
 from time import sleep, time
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class LongRunningOperation:
     """Class to represent a workspace in Microsoft Fabric"""
 
-    def __init__(self, operation_id, auth) -> None:
+    def __init__(self, operation_id, core_client: FabricClientCore) -> None:
         self.operation_id = operation_id
-        self.auth = auth
+        self.core_client = core_client
 
         self.state = self.get_operation_state()["status"]
 
 
     def get_operation_results(self):
-        """Get the results of an operation"""
-        url = f"https://api.fabric.microsoft.com/v1/operations/{self.operation_id}/result"
-
-        for _ in range(10):
-            response = requests.get(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code == 400:
-                return None
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error getting operation results: {response.status_code}, {response.text}")
-            break
-
-        return json.loads(response.text)
+        return self.core_client.get_operation_results(operation_id=self.operation_id)
     
     def get_operation_state(self):
-        """Get the state of an operation"""
-        url = f"https://api.fabric.microsoft.com/v1/operations/{self.operation_id}"
-
-        for _ in range(10):
-            response = requests.get(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error getting operation state: {response.status_code},  {response.text}")
-            break
-
-        return json.loads(response.text)    
+        return self.core_client.get_operation_state(operation_id=self.operation_id) 
     
     def wait_for_completion(self):
         """Wait for the operation to complete"""
-        max_iter = 20
         start_time = time()
         while self.state not in ('Succeeded', 'Failed'):
             self.state = self.get_operation_state()["status"]
@@ -63,7 +33,7 @@ class LongRunningOperation:
         return self.state
     
 
-def check_long_running_operation(headers, auth):
+def check_long_running_operation(headers, core_client):
     """Check the status of a long running operation"""
     location = headers.get('Location', None)
     operation_id = headers.get('x-ms-operation-id', None)
@@ -73,7 +43,7 @@ def check_long_running_operation(headers, auth):
     if not operation_id:
         print("Operation initiated, no operation id found")
         return None
-    lro = LongRunningOperation(operation_id=operation_id, auth=auth)
+    lro = LongRunningOperation(operation_id=operation_id, core_client=core_client)
     lro.wait_for_completion()
     
     return lro.get_operation_results()

msfabricpysdkcore/onelakeshortcut.py

@@ -1,12 +1,11 @@
 import json 
-import requests
-from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class OneLakeShortcut:
     """Class to represent a onelake shortcut in Microsoft Fabric"""
 
     def __init__(self, name, path, workspace_id, item_id, target,
-                  auth) -> None:
+                  core_client: FabricClientCore) -> None:
         
         self.name = name
         self.path = path
@@ -14,7 +13,7 @@ class OneLakeShortcut:
         self.item_id = item_id
         self.workspace_id = workspace_id
 
-        self.user_auth = auth
+        self.core_client = core_client
 
     def __str__(self) -> str:
         """Return a string representation of the workspace object"""
@@ -30,29 +29,16 @@ class OneLakeShortcut:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def from_dict(short_dict, auth):
+    def from_dict(short_dict, core_client):
         """Create OneLakeShortCut object from dictionary"""
         return OneLakeShortcut(name=short_dict['name'],
                                path=short_dict['path'], 
                                target=short_dict['target'], 
                                item_id=short_dict['itemId'], 
                                workspace_id=short_dict['workspaceId'], 
-                               auth=auth)
+                               core_client=core_client)
     
     def delete(self):
         """Delete the shortcut"""
-
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.item_id}/shortcuts/{self.path}/{self.name}"
-        for _ in range(10):
-            response = requests.delete(url=url, headers=self.user_auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error deleting shortcut: {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.delete_shortcut(workspace_id=self.workspace_id, item_id=self.item_id, path=self.path,
+                                                name=self.name)

msfabricpysdkcore/otheritems.py

@@ -1,19 +1,15 @@
-import json
-from time import sleep
-import requests
 from msfabricpysdkcore.item import Item
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 
 class Eventhouse(Item):
     """Class to represent a eventhouse in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, description=""):
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, description=""):
         super().__init__(id = id, display_name=display_name, type=type, 
-                         workspace_id=workspace_id, auth=auth, properties=properties, 
+                         workspace_id=workspace_id, core_client=core_client, properties=properties, 
                          description=description)
         
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         if "displayName" not in item_dict:
             item_dict["displayName"] = item_dict["display_name"]
         if "workspaceId" not in item_dict:
@@ -22,7 +18,7 @@ class Eventhouse(Item):
         return Eventhouse(id=item_dict['id'], display_name=item_dict['displayName'], 
                           type=item_dict['type'], workspace_id=item_dict['workspaceId'],
                           properties=item_dict.get('properties', None),
-                          description=item_dict.get('description', ""), auth=auth)
+                          description=item_dict.get('description', ""), core_client=core_client)
 
     def create_kql_database(self, display_name = None, description= None):
         from msfabricpysdkcore.coreapi import FabricClientCore
@@ -30,191 +26,170 @@ class Eventhouse(Item):
         creation_payload = {"databaseType" : "ReadWrite",
                             "parentEventhouseItemId" : self.id}
         
-        fcc = FabricClientCore(silent=True)
-
-        return fcc.create_kql_database(workspace_id = self.workspace_id,
-                                       display_name = display_name, description = description,
-                                       creation_payload= creation_payload)
+        return self.core_client.create_kql_database(self.workspace_id, display_name=display_name, description=description, creation_payload=creation_payload)
 
 class SparkJobDefinition(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return SparkJobDefinition(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def get_definition(self, format=None):
-        return super().get_definition(type="sparkJobDefinitions", format=format)
+        resp_dict = self.core_client.get_spark_job_definition_definition(self.workspace_id, self.id, format=format)
+        self.definition = resp_dict['definition']
+        return resp_dict
     
     def update_definition(self, definition):
-        return super().update_definition(definition=definition, type="sparkJobDefinitions")
+        return self.core_client.update_spark_job_definition_definition(self.workspace_id, self.id, definition)
     
     def run_on_demand_spark_job_definition(self, job_type = "sparkjob"):
-    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/sparkJobDefinitions/{sparkJobDefinitionId}/jobs/instances?jobType={jobType}
-        """Method to run a spark job definition on demand"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/sparkJobDefinitions/{self.id}/jobs/instances?jobType={job_type}"
-
-        for _ in range(10):
-            response = requests.post(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code == 202:
-                location = response.headers['Location']
-                job_instance_id = location.split('/')[-1]
-                
-                from msfabricpysdkcore import FabricClientCore
-                fc = FabricClientCore(silent=True)
-                fc.auth = self.auth
-                return fc.get_item_job_instance(workspace_id = self.workspace_id,
-                                                item_id = self.id,
-                                                job_instance_id = job_instance_id)
-            if response.status_code not in (200, 201, 202, 429):
-                raise Exception(f"Error running on demand spark job definition: {response.status_code}, {response.text}")
-            break
-        
-        return response
+        return self.core_client.run_on_demand_spark_job_definition(workspace_id=self.workspace_id, spark_job_definition_id=self.id, job_type=job_type)
 
 
 class Warehouse(Item):
     """Class to represent a warehouse in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Warehouse(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class KQLDatabase(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return KQLDatabase(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class KQLQueryset(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return KQLQueryset(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class Eventstream(Item):
     """Class to represent a eventstream in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
     
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Eventstream(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
 class MLExperiment(Item):
     """Class to represent a ml experiment in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
     
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return MLExperiment(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class MLModel(Item):
     """Class to represent a ml model in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return MLModel(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
 class Notebook(Item):
     """Class to represent a notebook in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Notebook(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def get_definition(self, format=None):
         """Method to get the definition of the notebook"""
-        return super().get_definition(type = "notebooks", format = format)
+        definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="notebooks", format=format)
+        self.definition = definition
+        return definition
     
     def update_definition(self, definition):
         """Method to update the definition of the notebook"""
-        return super().update_definition(definition, type = "notebooks")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="notebooks")
 
 class Report(Item):
     """Class to represent a report in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Report(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def get_definition(self, type=None, format=None):
         """Method to get the definition of the report"""
-        return super().get_definition(type = "reports", format = format)
+        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="reports", format=format)
+        return self.definition
     
     def update_definition(self, definition):
         """Method to update the definition of the report"""
-        return super().update_definition(definition, type = "reports")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="reports")
 
 class SemanticModel(Item):
     """Class to represent a semantic model in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return SemanticModel(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def get_definition(self, format=None):
         """Method to get the definition of the semantic model"""
-        return super().get_definition(type="semanticModels", format=format)
+        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="semanticModels", format=format)
+        return self.definition
     
     def update_definition(self, definition):
         """Method to update the definition of the semantic model"""
-        return super().update_definition(definition, type = "semanticModels")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="semanticModels")
 
 class DataPipeline(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return DataPipeline(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def run_on_demand_item_job(self, execution_data=None):
-        return super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)
+        return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id, job_type="Pipeline", execution_data=execution_data)
+    
     

msfabricpysdkcore/spark_custom_pool.py

@@ -1,13 +1,11 @@
 import json
-from time import sleep
-
-import requests 
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 
 class SparkCustomPool:
     """Class to represent a custom pool in Microsoft Fabric"""
 
-    def __init__(self, id, name, type, node_family, node_size, auto_scale, dynamic_executor_allocation, workspace_id, auth) -> None:
+    def __init__(self, id, name, type, node_family, node_size, auto_scale, dynamic_executor_allocation, workspace_id, core_client: FabricClientCore) -> None:
         
         self.id = id
         self.name = name
@@ -18,7 +16,7 @@ class SparkCustomPool:
         self.dynamic_executor_allocation = dynamic_executor_allocation
         self.workspace_id = workspace_id
         
-        self.auth = auth
+        self.core_client = core_client
 
     def __str__(self) -> str:
         """Return a string representation of the workspace object"""
@@ -37,7 +35,7 @@ class SparkCustomPool:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         """Create Item object from dictionary"""
 
         if 'autoScale' not in item_dict:
@@ -54,55 +52,17 @@ class SparkCustomPool:
         
         return SparkCustomPool(id=item_dict['id'], name=item_dict['name'], type=item_dict['type'], node_family=item_dict['nodeFamily'],
                                 node_size=item_dict['nodeSize'], auto_scale=item_dict['autoScale'], dynamic_executor_allocation=item_dict['dynamicExecutorAllocation'],
-                                workspace_id=item_dict['workspaceId'], auth=auth)
+                                workspace_id=item_dict['workspaceId'], core_client=core_client)
 
 
     def delete(self):
         """Delete the custom pool item"""
-        # DELETE http://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/spark/pools/{poolId}
-
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{self.id}"
-        for _ in range(10):
-            response = requests.delete(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error deleting spark pool: {response.status_code}, {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.delete_workspace_custom_pool(self.workspace_id, self.id)
     
 
     def update(self, name, node_family, node_size, auto_scale, dynamic_executor_allocation):
         """Update the custom pool item"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{self.id}"
-        body = {}
-
-        if name is not None:
-            body['name'] = name
-        if node_family is not None:
-            body['nodeFamily'] = node_family
-        if node_size is not None:
-            body['nodeSize'] = node_size
-        if auto_scale is not None:
-            body['autoScale'] = auto_scale
-        if dynamic_executor_allocation is not None:
-            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
-
-        if not body:
-            return self
-        for _ in range(10):
-            response = requests.patch(url=url, headers=self.auth.get_headers(), json=body)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error updating item: {response.status_code}, {response.text}")
-            break
-
+        _ = self.core_client.update_workspace_custom_pool(self.workspace_id, self.id, name, node_family, node_size, auto_scale, dynamic_executor_allocation)
         if name is not None:
             self.name = name
         if node_family is not None:

msfabricpysdkcore/tests/test_admin_apis.py

@@ -13,19 +13,19 @@ 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)
 
         self.assertEqual(ws.id, ws_clone.id)
 
-        # Get workspace access details
+        # List workspace access details
 
         ws_access = fca.list_workspace_access_details(ws.id)
         principials = ws_access["accessDetails"]
@@ -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,33 +16,30 @@ 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}"
+
+        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("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")
+        self.assertIn(pipeline_name, dp_names)
 
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline2")
+        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, "pipeline2")
+        self.assertEqual(dp.display_name, pipeline_name2)
         self.assertEqual(dp.id, dp2.id)
 
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline1")
+        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, "pipeline1")
+        self.assertEqual(dp.display_name, pipeline_name)
         self.assertEqual(dp.id, dp2.id)
-        status_code = fc.delete_data_pipeline(workspace_id, dp_new.id)
+        status_code = fc.delete_data_pipeline(workspace_id, dp.id)
         self.assertEqual(status_code, 200)