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

msfabricpysdkcore/item.py

@@ -45,15 +45,18 @@ class Item:
 
         return self.core_client.delete_item(self.workspace_id, self.id, type=type)
     
-    def get_definition(self, type = None, format = None):
+    def get_definition(self, type = None, format = None, **kwargs):
         """Get the definition of the item"""
-        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, format=format)
+        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, format=format, **kwargs)
 
         self.definition = resp_dict['definition']
         return resp_dict
 
+    def list_connections(self):
+        """List connections of an item in a workspace"""
+        return self.core_client.list_item_connections(workspace_id=self.workspace_id, item_id=self.id)
 
-    def update(self, display_name = None, description = None, type = None, return_item="Default"):
+    def update(self, display_name = None, description = None, type = None, return_item=False):
         """Update the item"""
 
         resp_dict = self.core_client.update_item(workspace_id=self.workspace_id, item_id=self.id,
@@ -66,10 +69,12 @@ class Item:
 
         return resp_dict
 
-    def update_definition(self, definition, type = None):
+    def update_definition(self, definition, type = None, **kwargs):
         """Update the item definition"""
+        if not type:
+            type = self.type
         response = self.core_client.update_item_definition(workspace_id=self.workspace_id, item_id=self.id, 
-                                                           definition=definition, type=type)
+                                                           definition=definition, type=type, **kwargs)
 
         self.definition = definition 
         return response
@@ -100,15 +105,49 @@ class Item:
         """Cancel a job instance ofjob the item"""
         return self.core_client.cancel_item_job_instance(workspace_id=self.workspace_id, item_id=self.id,
                                                          job_instance_id=job_instance_id)
-        
+    
+    def create_item_schedule(self, job_type, configuration, enabled):
+        """Create a schedule for the job instance"""
+        return self.core_client.create_item_schedule(workspace_id=self.workspace_id,
+                                                     item_id=self.id,
+                                                     job_type=job_type,
+                                                     configuration=configuration,
+                                                     enabled=enabled)
+    
     def get_item_job_instance(self, job_instance_id):
         """Get the job instance of the item"""
         return self.core_client.get_item_job_instance(workspace_id=self.workspace_id, item_id=self.id,
                                                       job_instance_id=job_instance_id)
+    def get_item_schedule(self, job_type, schedule_id):
+        """Get the schedule for the job instance"""
+        return self.core_client.get_item_schedule(workspace_id=self.workspace_id,
+                                                 item_id=self.id,
+                                                 job_type=job_type,
+                                                 schedule_id=schedule_id)
+    
+    def list_item_job_instances(self):
+        """List all job instances for the job instance"""
+        return self.core_client.list_item_job_instances(workspace_id=self.workspace_id,
+                                                        item_id=self.id)                                      
+    
+    def list_item_schedules(self, job_type):
+        """List all schedules for the job instance"""
+        return self.core_client.list_item_schedules(workspace_id=self.workspace_id,
+                                                  item_id=self.id,
+                                                  job_type=job_type)
 
     def run_on_demand_item_job(self, job_type, execution_data = None):
         return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id,
                                                        job_type=job_type, execution_data=execution_data)
+    
+    def update_item_schedule(self, job_type, schedule_id, configuration, enabled):
+        """Update the schedule for the job instance"""
+        return self.core_client.update_item_schedule(workspace_id=self.workspace_id,
+                                                     item_id=self.id,
+                                                     job_type=job_type,
+                                                     schedule_id=schedule_id,
+                                                     configuration=configuration,
+                                                     enabled=enabled)
 
     
     # External Data Shares

msfabricpysdkcore/job_instance.py

@@ -51,4 +51,5 @@ class JobInstance:
         """Cancel the job instance"""
         return self.core_client.cancel_item_job_instance(workspace_id=self.workspace_id,
                                                          item_id=self.item_id,
-                                                         job_instance_id=self.id)
+                                                         job_instance_id=self.id)
+    

msfabricpysdkcore/otheritems.py

@@ -20,6 +20,14 @@ class Eventhouse(Item):
                           properties=item_dict.get('properties', 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 eventhouse"""
+        return super().get_definition(type="eventhouses", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the eventhouse"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventhouses")
+
     def create_kql_database(self, display_name = None, description= None):
         from msfabricpysdkcore.coreapi import FabricClientCore
         """Method to create a kql database in the eventhouse"""
@@ -40,9 +48,7 @@ class SparkJobDefinition(Item):
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
     def get_definition(self, format=None):
-        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
+        return super().get_definition(type="sparkJobDefinitions", format=format)
     
     def update_definition(self, definition):
         return self.core_client.update_spark_job_definition_definition(self.workspace_id, self.id, definition)
@@ -62,6 +68,25 @@ class Warehouse(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
+class KQLDashboard(Item):
+    """Class to represent a kql dashboard in Microsoft Fabric"""
+
+    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, core_client):
+        return KQLDashboard(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', ""), core_client=core_client)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the kql dashboard"""
+        return super().get_definition(type="kqlDashboards", format=format)
+
+    def update_definition(self, definition):
+        """Method to update the definition of the kql dashboard"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlDashboards")
+
 class KQLDatabase(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
@@ -73,6 +98,14 @@ class KQLDatabase(Item):
             properties=item_dict.get('properties', None),
             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 kql database"""
+        return super().get_definition(type="kqlDatabases", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the kql database"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlDatabases")
+
 class KQLQueryset(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
@@ -83,6 +116,17 @@ class KQLQueryset(Item):
         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', ""), core_client=core_client)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the kql queryset"""
+        return super().get_definition(type="kqlQuerysets", format=format)
+    
+    def update_definition(self, definition, update_metadata=None):
+        """Method to update the definition of the kql queryset"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlQuerysets",
+                                                       update_metadata=update_metadata)
+    
+    
 
 class Eventstream(Item):
     """Class to represent a eventstream in Microsoft Fabric"""
@@ -94,7 +138,60 @@ class Eventstream(Item):
         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', ""), core_client=core_client)
+
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the eventstream"""
+        return super().get_definition(type="eventstreams", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the eventstream"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventstreams")
+
+class GraphQLApi(Item):
+    """Class to represent a graphql api in Microsoft Fabric"""
+     
+    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, core_client):
+        return GraphQLApi(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', ""), core_client=core_client)
     
+class MirroredDatabase(Item):
+    """Class to represent a mirrored database in Microsoft Fabric"""
+     
+    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, core_client):
+        return MirroredDatabase(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', ""), core_client=core_client)
+    
+    def get_definition(self): 
+        """Method to get the definition of the mirrored database"""
+        return super().get_definition(type="mirroredDatabases")
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the mirrored database"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="mirroredDatabases")
+
+    def get_mirrored_database_definition(self, mirrored_database_id):
+        return self.core_client.get_mirrored_database_definition(workspace_id=self.id,
+                                                                 mirrored_database_id=mirrored_database_id)
+    def get_mirroring_status(self):
+        return self.core_client.get_mirroring_status(workspace_id=self.workspace_id, mirrored_database_id=self.id)
+
+    def get_tables_mirroring_status(self):
+        return self.core_client.get_tables_mirroring_status(workspace_id=self.workspace_id, mirrored_database_id=self.id)
+
+    def start_mirroring(self):
+        return self.core_client.start_mirroring(workspace_id=self.workspace_id, mirrored_database_id=self.id)
+
+    def stop_mirroring(self):
+        return self.core_client.stop_mirroring(workspace_id=self.workspace_id, mirrored_database_id=self.id)
+
 class MLExperiment(Item):
     """Class to represent a ml experiment in Microsoft Fabric"""
      
@@ -117,6 +214,25 @@ class MLModel(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
+class MountedDataFactory(Item):
+    """Class to represent a mounted data factory in Microsoft Fabric"""
+     
+    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, core_client):
+        return MountedDataFactory(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', ""), core_client=core_client)
+
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the mountedDataFactory"""
+        return super().get_definition(type="mountedDataFactories", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the mountedDataFactory"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="mountedDataFactories")
+
 class Notebook(Item):
     """Class to represent a notebook in Microsoft Fabric"""
      
@@ -130,14 +246,31 @@ class Notebook(Item):
     
     def get_definition(self, format=None):
         """Method to get the definition of the notebook"""
-        definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="notebooks", format=format)
-        self.definition = definition
-        return definition
+        return super().get_definition(type="notebooks", format=format)
     
     def update_definition(self, definition):
         """Method to update the definition of the notebook"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="notebooks")
 
+class Reflex(Item):
+    """Class to represent a reflex in Microsoft Fabric"""
+     
+    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, core_client):
+        return Reflex(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', ""), core_client=core_client)
+
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the reflex"""
+        return super().get_definition(type="reflexes", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the reflex"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="reflexes")
+    
 class Report(Item):
     """Class to represent a report in Microsoft Fabric"""
      
@@ -151,8 +284,7 @@ class Report(Item):
     
     def get_definition(self, type=None, format=None):
         """Method to get the definition of the report"""
-        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="reports", format=format)
-        return self.definition
+        return super().get_definition(type="reports", format=format)
     
     def update_definition(self, definition):
         """Method to update the definition of the report"""
@@ -171,13 +303,23 @@ class SemanticModel(Item):
     
     def get_definition(self, format=None):
         """Method to get the definition of the semantic model"""
-        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="semanticModels", format=format)
-        return self.definition
+        return super().get_definition(type="semanticModels", format=format)
     
     def update_definition(self, definition):
         """Method to update the definition of the semantic model"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="semanticModels")
 
+class SQLDatabase(Item):
+    """Class to represent a sql database in Microsoft Fabric"""
+     
+    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, core_client):
+        return SQLDatabase(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', ""), core_client=core_client)
+
 class DataPipeline(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
@@ -189,6 +331,13 @@ class DataPipeline(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
+    def get_definition(self, type=None, format=None, **kwargs):
+        return super().get_definition(type="dataPipelines", format=format, **kwargs)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the dataPipeline"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="dataPipelines")
+    
     def run_on_demand_item_job(self, execution_data=None):
         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/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": "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)
+        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 = "63aa9e13-4912-4abe-9156-8a56e565b7a3"
+
+        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/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)
+