msfabricpysdkcore 0.2.7__tar.gz → 0.2.8__tar.gz

{msfabricpysdkcore-0.2.7 → msfabricpysdkcore-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msfabricpysdkcore
-Version: 0.2.7
+Version: 0.2.8
 Summary: A Python SDK for Microsoft Fabric
 Author: Andreas Rederer
 Project-URL: Homepage, https://github.com/DaSenf1860/ms-fabric-sdk-core

{msfabricpysdkcore-0.2.7 → msfabricpysdkcore-0.2.8}/msfabricpysdkcore/coreapi.py

@@ -2267,7 +2267,7 @@ class FabricClientCore(FabricClient):
 
         return response
 
-    def get_workspace(self, id = None, name = None):
+    def get_workspace(self, id = None, name = None, return_item=True):
         """Get workspace by id or name
         Args:
             id (str): The ID of the workspace
@@ -2278,12 +2278,12 @@ class FabricClientCore(FabricClient):
             ValueError: If neither id nor name is provided
         """
         if id:
-            return self.get_workspace_by_id(id)
+            return self.get_workspace_by_id(id, return_item=return_item)
         if name:
             return self.get_workspace_by_name(name)
         raise ValueError("Either id or name must be provided")
     
-    def get_workspace_by_id(self, id):
+    def get_workspace_by_id(self, id, return_item=True):
         """Get workspace by id
         Args:
             id (str): The ID of the workspace
@@ -2296,9 +2296,9 @@ class FabricClientCore(FabricClient):
 
         ws_dict = self.calling_routine(url, operation="GET", response_codes=[200, 404], error_message="Error getting workspace", return_format="json")
 
-        ws = Workspace.from_dict(ws_dict, core_client=self)
-
-        return ws
+        if return_item:
+            return Workspace.from_dict(ws_dict, core_client=self)
+        return ws_dict
 
     def get_workspace_by_name(self, name):
         """Get workspace by name

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_admin_apis.py

@@ -0,0 +1,174 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fca = FabricClientAdmin()
+                  
+    def test_admin_api(self):
+        fca = self.fca
+
+        user_id = '1dc64c6e-7a10-4ea9-8488-85d0739a377d'
+
+        # List workspaces
+        ws = fca.list_workspaces(name="testitems")[0]
+
+        self.assertEqual(ws.name, "testitems")
+
+        # Get workspace
+        ws_clone = fca.get_workspace(workspace_id=ws.id)
+
+        self.assertEqual(ws.id, ws_clone.id)
+
+        # Discover git connections 
+      
+        git_connections = fca.discover_git_connections()
+
+        self.assertGreater(len(git_connections), 0)
+
+        git_conn = [g for g in git_connections if g['workspaceId'] == '63aa9e13-4912-4abe-9156-8a56e565b7a3'][0]
+        self.assertEqual(git_conn['gitProviderDetails']['ownerName'], 'DaSenf1860')
+
+        # List workspace access details
+
+        ws_access = fca.list_workspace_access_details(ws.id)
+        principials = ws_access["accessDetails"]
+        principials_ids = [p["principal"]["id"] for p in principials]
+        self.assertIn(user_id, principials_ids)
+
+        # Get access entities
+
+        access_entities = fca.list_access_entities(user_id, type="Notebook")
+        self.assertGreater(len(access_entities), 0)
+
+        # List tenant settings
+    
+        settings = fca.list_tenant_settings()
+        monitoring_setting = [setting for setting in settings if setting['settingName'] == 'PlatformMonitoringTenantSetting'][0]
+
+        self.assertIsNotNone(monitoring_setting)
+ 
+        # List tenant settings capacity overrides
+    
+        settings_capa = fca.list_capacities_tenant_settings_overrides()
+        setting = [s for s in settings_capa if s['id'] == '9E7E757D-D567-4FB3-BC4F-D230AABF2A00']
+
+        self.assertGreater(len(setting), 0)
+
+ 
+        # List tenant settings overrides on domains
+
+        domain_overrides = fca.list_domain_tenant_settings_overrides()
+        len(domain_overrides) == 0 
+        self.assertEqual(len(domain_overrides), 0)
+
+        # List tenant settings overrides on workspaces
+
+        workspace_overrides = fca.list_workspace_tenant_settings_overrides()
+        wover = [w for w in workspace_overrides if w["id"] == "192333b2-5f89-4da5-ae69-64a3ee4c649c"]
+        self.assertIsNotNone(wover)
+
+        # Update tenant settings
+
+        if monitoring_setting["enabled"] == False:
+            changed_settings = fca.update_tenant_setting("PlatformMonitoringTenantSetting", enabled=True)
+            "tenantSettings" in changed_settings and len(changed_settings["tenantSettings"]) > 0 and changed_settings["tenantSettings"][0]["enabled"] == True
+        else: 
+            changed_settings = fca.update_tenant_setting("PlatformMonitoringTenantSetting", enabled=False)
+            "tenantSettings" in changed_settings and len(changed_settings["tenantSettings"]) > 0 and changed_settings["tenantSettings"][0]["enabled"] == False
+
+
+
+        # Update tenant settings capacity overrides
+
+ 
+        enabledSecurityGroups = [{'graphId': '73ba0244-b701-41ed-96d9-79917b74f5f8', 'name': 'fabricadmins'}]
+        excludedSecurityGroups = [{'graphId': '16450670-829a-4b70-b80e-6524eea067cb', 'name': 'fabricuser'}]
+        feedback = fca.update_capacity_tenant_setting_override("9e7e757d-d567-4fb3-bc4f-d230aabf2a00",
+                                                    "PlatformMonitoringTenantSetting",
+                                                    enabled=True,
+                                                    excluded_security_groups=excludedSecurityGroups,
+                                                    enabled_security_groups=enabledSecurityGroups)
+        
+        
+        # List tenant settings overrides by capacity id
+ 
+        settings_capa = fca.list_capacity_tenant_settings_overrides_by_capacity_id("9e7e757d-d567-4fb3-bc4f-d230aabf2a00")
+        setting = [s for s in settings_capa if s['settingName'] == 'PlatformMonitoringTenantSetting']
+
+        self.assertGreater(len(setting), 0)
+
+        # Update tenant settings capacity overrides
+
+        status_code = fca.delete_capacity_tenant_setting_override("9e7e757d-d567-4fb3-bc4f-d230aabf2a00", "PlatformMonitoringTenantSetting")
+
+        self.assertEqual(status_code, 200)
+
+        settings = [set for set in fca.list_capacity_tenant_settings_overrides_by_capacity_id("9e7e757d-d567-4fb3-bc4f-d230aabf2a00") if set["settingName"] == "PlatformMonitoringTenantSetting"]
+
+        self.assertEqual(len(settings), 0)
+
+        self.assertIn("overrides", feedback)
+        self.assertGreater(len(feedback["overrides"]), 0)
+        self.assertEqual(feedback["overrides"][0]["enabled"], True)
+
+ 
+
+
+
+
+
+        # List items
+
+        item_list = fca.list_items(workspace_id=ws.id)
+        self.assertGreater(len(item_list), 0)
+
+        # Get item
+
+        item = fca.get_item(workspace_id=ws.id, item_id=item_list[0].id)
+        self.assertEqual(item.id, item_list[0].id)
+
+        # Get item access details
+
+        item_access = fca.list_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
+        principials = item_access["accessDetails"]
+
+        principials_ids = [p["principal"]["id"] for p in principials]
+
+        self.assertIn(user_id, principials_ids)
+
+
+    def test_labels(self):
+
+        fca = self.fca
+
+        items = [{"id": "e79d7a0e-1741-4ddf-a705-b861f2775f97", "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)
+        self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
+
+    def test_admin_external_data_shares(self):
+
+        fca = self.fca
+
+        data_shares = fca.list_external_data_shares()
+        ws_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+
+        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()
+
+        # data_shares = [d for d in data_shares if d['workspaceId'] == ws_id]
+
+        # self.assertEqual(data_shares[0]['status'], 'Revoked')

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_admin_tags.py

@@ -0,0 +1,46 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fca = FabricClientAdmin()
+                  
+    def test_admin_api(self):
+        fca = self.fca
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        if len(sdk_tag) > 0:
+            sdk_tag = sdk_tag[0]
+            resp = fca.delete_tag(tag_id=sdk_tag["id"])
+            self.assertEqual(resp, 200)
+      
+        new_tags = [{"displayName": "sdk_tag_temp"}]
+        resp = fca.bulk_create_tags(create_tags_request=new_tags)
+        self.assertEqual(len(resp["tags"]), 1)
+        resp = resp["tags"][0]
+        self.assertEqual(resp["displayName"], "sdk_tag_temp")
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        self.assertEqual(len(sdk_tag), 1)
+        sdk_tag = sdk_tag[0]
+
+        self.assertIsNotNone(sdk_tag["id"])
+
+        resp = fca.update_tag(tag_id=sdk_tag["id"], display_name="sdk_tag_updated")
+        self.assertIsNotNone(resp["id"])
+        self.assertEqual(resp["displayName"], "sdk_tag_updated")
+
+
+        resp = fca.delete_tag(tag_id=resp["id"])
+        self.assertEqual(resp, 200)
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        self.assertEqual(len(sdk_tag), 0)
+
+
+

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_apache_airflow_job.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_apache_airflow_job(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "4e685286-d909-4ccb-911f-590ee3c3df14"
+
+        apache_airflow_job = fcc.list_apache_airflow_jobs(workspace_id=workspace_id)
+        for apache_airflow_job in apache_airflow_job:
+            if apache_airflow_job.id != item_id:
+                resp = fcc.delete_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job.id)
+                self.assertEqual(resp, 200)
+
+        apache_airflow_job_definition = fcc.get_apache_airflow_job_definition(workspace_id=workspace_id, apache_airflow_job_id=item_id)
+        self.assertIn("definition", apache_airflow_job_definition)
+        definition = apache_airflow_job_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"copyjob{date_str}"
+
+        apache_airflow_job_new = fcc.create_apache_airflow_job(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(apache_airflow_job_new.display_name, date_str)
+
+        apache_airflow_job_get = fcc.get_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id)
+        self.assertEqual(apache_airflow_job_get.display_name, date_str)
+
+        apache_airflow_job = fcc.list_apache_airflow_jobs(workspace_id=workspace_id)
+        self.assertEqual(len(apache_airflow_job), 2)
+
+        date_str_updated = date_str + "_updated"
+        apache_airflow_job_updated = fcc.update_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(apache_airflow_job_updated.display_name, date_str_updated)
+
+        apache_airflow_job_updated = fcc.update_apache_airflow_job_definition(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job_new.id, definition=definition)
+        self.assertEqual(apache_airflow_job_updated.status_code, 200)
+
+        for apache_airflow_job in apache_airflow_job:
+            if apache_airflow_job.id != item_id:
+                resp = fcc.delete_apache_airflow_job(workspace_id=workspace_id, apache_airflow_job_id=apache_airflow_job.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_connection.py

@@ -0,0 +1,111 @@
+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_connection(self):
+
+        datetime_str = datetime.now().strftime("%Y%m%H%M%S")
+        datetime_str
+        fc = self.fc
+
+        # display_name = "ContosoCloudConnection" + datetime_str
+
+        # cr = {"connectivityType": "ShareableCloud",
+        #     "displayName": display_name,
+        #     "connectionDetails": {
+        #         'type': "SQL",
+        #         'creationMethod': 'SQL',
+        #         "parameters": [
+        #             {
+        #                 "dataType": "Text",
+        #                 "name": "server",
+        #                 "value": "dfsdemo.database.windows.net"
+        #             },
+        #             {
+        #                 "dataType": "Text",
+        #                 "name": "database",
+        #                 "value": "dfsdemo"
+        #             }
+        #             ]},
+        #     'privacyLevel': 'Organizational',
+        #     'credentialDetails': {'credentials':{'credentialType': 'Basic', 
+        #                                         'userName': 'new_user', 
+        #                                         'password': 'StrongPassword123!'},
+        #                             'singleSignOnType': 'None',
+        #                             'connectionEncryption': 'NotEncrypted',
+        #                             'skipTestConnection': False}
+        # }
+            
+
+
+        # connection = fc.create_connection(connection_request=cr)
+        # self.assertIsNotNone(connection)
+        # self.assertIn('id', connection)
+        # self.assertIn('displayName', connection)
+        # self.assertEqual(connection['displayName'], display_name)
+
+        # connection2 = fc.get_connection(connection_name=display_name)
+        # self.assertEqual(connection['id'], connection2['id'])
+
+
+        # connections = fc.list_connections()
+        # connection_names = [conn['displayName'] for conn in connections]
+        # self.assertIn(display_name, connection_names)
+
+        # id = connection['id']
+
+        # role_assis = fc.list_connection_role_assignments(connection_id=id)
+        # self.assertEqual(len(role_assis), 1)
+
+        # principal = {"id" : "755f273c-98f8-408c-a886-691794938bd8",
+        #             "type" : "ServicePrincipal"}
+
+        # add_role_assi = fc.add_connection_role_assignment(connection_id=id, principal=principal, role='User')
+        # self.assertIsNotNone(add_role_assi)
+        # self.assertIn('id', add_role_assi)
+        # role_assi_id = add_role_assi['id']
+
+        # role_assis = fc.list_connection_role_assignments(connection_id=id)
+        # self.assertEqual(len(role_assis), 2)
+
+        # role_assi = fc.get_connection_role_assignment(connection_id=id,
+        #                                               connection_role_assignment_id=role_assi_id)
+        # self.assertEqual(role_assi['id'], role_assi_id)
+
+        # role_assi = fc.update_connection_role_assignment(connection_id=id,
+        #                                      connection_role_assignment_id=role_assi_id,
+        #                                      role='UserWithReshare')
+        # self.assertEqual(role_assi['role'], 'UserWithReshare')
+
+        # status_code = fc.delete_connection_role_assignment(connection_id=id,
+        #                                                    connection_role_assignment_id=role_assi_id)
+        # self.assertEqual(status_code, 200)
+
+
+        # cr = {
+        # "connectivityType": "ShareableCloud",
+        # "displayName": f"sqlserver{datetime_str}"
+        # }
+
+        # updated_connection = fc.update_connection(connection_id=id, connection_request=cr)
+        # self.assertIsNotNone(updated_connection)
+
+
+        # connection2 = fc.get_connection(connection_id=id)
+        # self.assertEqual(connection['id'], connection2['id'])
+        # self.assertEqual(connection2['displayName'], f"sqlserver{datetime_str}")
+
+        # status_code = fc.delete_connection(connection_id=id)
+        # self.assertEqual(status_code, 200)
+

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_copy_jobs.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_copy_jobs(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "a9e59ec1-524b-49b1-a185-37e47dc0ceb9"
+
+        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
+        for copy_job in copy_jobs:
+            if copy_job.id != item_id:
+                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
+                self.assertEqual(resp, 200)
+
+        copy_job_definition = fcc.get_copy_job_definition(workspace_id=workspace_id, copy_job_id=item_id)
+        self.assertIn("definition", copy_job_definition)
+        definition = copy_job_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"copyjob{date_str}"
+
+        copy_job_new = fcc.create_copy_job(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(copy_job_new.display_name, date_str)
+
+        copy_job_get = fcc.get_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id)
+        self.assertEqual(copy_job_get.display_name, date_str)
+
+        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
+        self.assertEqual(len(copy_jobs), 2)
+
+        date_str_updated = date_str + "_updated"
+        copy_job_updated = fcc.update_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(copy_job_updated.display_name, date_str_updated)
+
+        copy_job_updated = fcc.update_copy_job_definition(workspace_id=workspace_id, copy_job_id=copy_job_new.id, definition=definition)
+        self.assertEqual(copy_job_updated.status_code, 200)
+
+        for copy_job in copy_jobs:
+            if copy_job.id != item_id:
+                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_dataflows.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_dataflows(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "8bc6f2f1-2ef9-4dc1-ab47-f55aa90e4088"
+
+        dataflows = fcc.list_dataflows(workspace_id=workspace_id)
+        for dataflow in dataflows:
+            if dataflow.id != item_id:
+                resp = fcc.delete_dataflow(workspace_id=workspace_id, dataflow_id=dataflow.id)
+                self.assertEqual(resp, 200)
+
+        dataflow_definition = fcc.get_dataflow_definition(workspace_id=workspace_id, dataflow_id=item_id)
+        self.assertIn("definition", dataflow_definition)
+        definition = dataflow_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"dataflow{date_str}"
+
+        dataflow_new = fcc.create_dataflow(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(dataflow_new.display_name, date_str)
+
+        dataflow_get = fcc.get_dataflow(workspace_id=workspace_id, dataflow_id=dataflow_new.id)
+        self.assertEqual(dataflow_get.display_name, date_str)
+
+        dataflows = fcc.list_dataflows(workspace_id=workspace_id)
+        self.assertEqual(len(dataflows), 2)
+
+        date_str_updated = date_str + "_updated"
+        dataflow_updated = fcc.update_dataflow(workspace_id=workspace_id, dataflow_id=dataflow_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(dataflow_updated.display_name, date_str_updated)
+
+        dataflow_updated = fcc.update_dataflow_definition(workspace_id=workspace_id, dataflow_id=dataflow_new.id, definition=definition)
+        self.assertEqual(dataflow_updated.status_code, 200)
+
+        for dataflow in dataflows:
+            if dataflow.id != item_id:
+                resp = fcc.delete_dataflow(workspace_id=workspace_id, dataflow_id=dataflow.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore-0.2.8/msfabricpysdkcore/tests/test_datapipelines.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_data_pipelines(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "b7746e38-5409-487a-969c-fb7cb026b5d3"
+
+        data_pipelines = fcc.list_data_pipelines(workspace_id=workspace_id)
+        for data_pipeline in data_pipelines:
+            if data_pipeline.id != item_id:
+                resp = fcc.delete_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline.id)
+                self.assertEqual(resp, 200)
+
+        data_pipeline_definition = fcc.get_data_pipeline_definition(workspace_id=workspace_id, data_pipeline_id=item_id)
+        self.assertIn("definition", data_pipeline_definition)
+        definition = data_pipeline_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"data_pipeline{date_str}"
+
+        data_pipeline_new = fcc.create_data_pipeline(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(data_pipeline_new.display_name, date_str)
+
+        data_pipeline_get = fcc.get_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id)
+        self.assertEqual(data_pipeline_get.display_name, date_str)
+
+        data_pipelines = fcc.list_data_pipelines(workspace_id=workspace_id)
+        self.assertEqual(len(data_pipelines), 2)
+
+        date_str_updated = date_str + "_updated"
+        data_pipeline_updated = fcc.update_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(data_pipeline_updated.display_name, date_str_updated)
+
+        data_pipeline_updated = fcc.update_data_pipeline_definition(workspace_id=workspace_id, data_pipeline_id=data_pipeline_new.id, definition=definition)
+        self.assertEqual(data_pipeline_updated.status_code, 200)
+
+        for data_pipeline in data_pipelines:
+            if data_pipeline.id != item_id:
+                resp = fcc.delete_data_pipeline(workspace_id=workspace_id, data_pipeline_id=data_pipeline.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+