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

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/tests/test_datapipelines.py

@@ -1,45 +1,60 @@
 import unittest
-from datetime import datetime
 from dotenv import load_dotenv
-from time import sleep
-from msfabricpysdkcore.coreapi import FabricClientCore
-
+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)
-        #load_dotenv()
-        self.fc = FabricClientCore()
-
+        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)
 
-        fc = self.fc
-        workspace_id = '63aa9e13-4912-4abe-9156-8a56e565b7a3'
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        pipeline_name = f"pipeline_{datetime_str}"
 
-        dp = fc.create_data_pipeline(workspace_id, display_name=pipeline_name, description="asda")
-        dp.update_definition(dp.definition)
 
-        dps = fc.list_data_pipelines(workspace_id)
-        dp_names = [dp.display_name for dp in dps]
-        self.assertGreater(len(dps), 0)
-        self.assertIn(pipeline_name, dp_names)
 
-        self.assertEqual(dp.display_name, pipeline_name)
-        pipeline_name2 = f"pipeline_{datetime_str}_2"
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name2, return_item=True)
 
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, pipeline_name2)
-        self.assertEqual(dp.id, dp2.id)
 
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name=pipeline_name, return_item=True)
 
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, pipeline_name)
-        self.assertEqual(dp.id, dp2.id)
-        status_code = fc.delete_data_pipeline(workspace_id, dp.id)
-        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_deployment_pipelinev2.py

@@ -0,0 +1,135 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from datetime import datetime
+from dotenv import load_dotenv
+import time
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        
+    def test_deployment_pipeline2(self):
+        fcc = self.fc
+        workspace_id = "72d9d955-bd1e-42c7-9746-208f7cbc8956"
+
+        user_id = "e0505016-ef55-4ca7-b106-e085cc201823"
+        capacity_id = "9e7e757d-d567-4fb3-bc4f-d230aabf2a00"
+
+        prod_workspace = fcc.create_workspace("sdkswedenproddeploy")
+        prod_workspace.assign_to_capacity(capacity_id)
+
+        stages =  [
+            {
+            "displayName": "Development",
+            "description": "Development stage description",
+            "isPublic": False
+            },
+            {
+            "displayName": "Production",
+            "description": "Production stage description",
+            "isPublic":True
+            }
+        ]
+
+        pipes = fcc.list_deployment_pipelines(with_details=False)
+        for pipe in pipes:
+            if "sdk" in pipe["displayName"]:
+                fcc.delete_deployment_pipeline(deployment_pipeline_id=pipe["id"])
+        
+        pipe =fcc.create_deployment_pipeline(display_name="sdktestpipeline",
+                              description="Test Deployment Pipeline Description",
+                              stages=stages)
+        
+        self.assertIsNotNone(pipe.id)
+        pipe_id = pipe.id
+
+        for stage in pipe.stages:
+            if stage["displayName"] == "Development":
+                dev_stage = stage
+            else:
+                prod_stage = stage
+        
+        stage = fcc.get_deployment_pipeline_stage(deployment_pipeline_id=pipe_id,
+                                                  stage_id=dev_stage["id"])
+        self.assertIsNotNone(stage.id)
+        resp = fcc.assign_workspace_to_stage(deployment_pipeline_id=pipe_id,
+                              stage_id=dev_stage["id"],
+                              workspace_id=workspace_id)
+        self.assertEqual(resp, 200)
+
+        resp = fcc.assign_workspace_to_stage(deployment_pipeline_id=pipe_id,
+                              stage_id=prod_stage["id"],
+                              workspace_id=prod_workspace.id)
+        self.assertEqual(resp, 200)
+        principal = {
+            "id": user_id,
+            "type": "User"
+        }
+
+        resp = fcc.add_deployment_pipeline_role_assignment(deployment_pipeline_id=pipe_id,principal=principal, role="Admin")
+        self.assertEqual(resp, 200)
+
+        roles = fcc.list_deployment_pipeline_role_assignments(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(roles) == 2)
+
+        resp = fcc.delete_deployment_pipeline_role_assignment(deployment_pipeline_id=pipe_id, principal_id=user_id)
+        self.assertEqual(resp, 200)
+
+        roles = fcc.list_deployment_pipeline_role_assignments(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(roles) == 1)
+
+        pipes = fcc.list_deployment_pipelines(with_details=False)
+        sdk_pipes = [pipe for pipe in pipes  if "sdk" in pipe["displayName"]]
+        self.assertTrue(len(sdk_pipes) > 0)
+
+        resp = fcc.deploy_stage_content(deployment_pipeline_id=pipe_id,
+                        source_stage_id=dev_stage["id"],
+                        target_stage_id=prod_stage["id"], wait_for_completion=False)
+        self.assertEqual(resp.status_code, 202)
+
+        ops = fcc.list_deployment_pipeline_operations(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(ops) > 0)
+
+        ops = fcc.get_deployment_pipeline_operation(deployment_pipeline_id=pipe_id, operation_id=ops[0]["id"])
+        self.assertIsNotNone(ops["id"])
+
+        stages = fcc.list_deployment_pipeline_stages(deployment_pipeline_id=pipe_id)
+        self.assertTrue(len(stages) == 2)
+
+        items = fcc.list_deployment_pipeline_stage_items(deployment_pipeline_id=pipe_id, stage_id=dev_stage["id"])
+        self.assertTrue(len(items) == 1)
+
+        updated_pipe = fcc.update_deployment_pipeline(deployment_pipeline_id=pipe.id, display_name="sdknewname", description="newdescription")
+        self.assertIsNotNone(updated_pipe.id)
+
+        pipe = fcc.get_deployment_pipeline(pipe_id)
+        self.assertIsNotNone(pipe.id)
+        self.assertTrue(pipe.display_name == "sdknewname")
+
+        updated_stage = fcc.update_deployment_pipeline_stage(deployment_pipeline_id=pipe_id, stage_id=prod_stage["id"],
+                                                     display_name="newname", description="newdescription")
+        self.assertIsNotNone(updated_stage["id"])
+
+        stage = fcc.get_deployment_pipeline_stage(deployment_pipeline_id=pipe_id, stage_id=prod_stage["id"])
+        self.assertIsNotNone(stage.id)
+        self.assertTrue(stage.display_name == "newname")
+
+        for _ in range(10):
+            ops = fcc.get_deployment_pipeline_operation(deployment_pipeline_id=pipe_id, operation_id=ops["id"])
+            if ops["status"] != "Running":
+                break
+            else:
+                time.sleep(5)
+
+        resp = fcc.unassign_workspace_from_stage(deployment_pipeline_id=pipe_id,stage_id=prod_stage["id"])
+        self.assertEqual(resp, 200)
+
+        prod_workspace.delete()
+
+        resp = fcc.delete_deployment_pipeline(deployment_pipeline_id=pipe_id)
+        self.assertEqual(resp, 200)

msfabricpysdkcore/tests/test_eventstream_topology.py

@@ -0,0 +1,82 @@
+
+# import unittest
+# from dotenv import load_dotenv
+# from msfabricpysdkcore import FabricClientCore
+# from datetime import datetime
+# from time import sleep
+# load_dotenv()
+
+# class TestFabricClientCore(unittest.TestCase):
+
+#     def __init__(self, *args, **kwargs):
+#         super(TestFabricClientCore, self).__init__(*args, **kwargs)
+                  
+#     def test_eventstream_topology(self):
+
+        # fcc = FabricClientCore()
+
+        # workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+
+        # item_id = "94f4b54b-980b-43f9-8b67-ded8028cf1b9"
+        # custom_destination_id = "acd90d61-2792-4494-9f17-c822f2fb984d"
+        # custom_source_id = "9f382928-7d42-43f9-b02b-1b1352ad3ecd"
+        # source_id = "e58db369-e473-40f4-bedd-022b60540b17"
+        # destination_id = "2446e6cf-98c9-45cb-a102-78d2ca3eb257"
+
+
+        # topology = fcc.get_eventstream_topology(workspace_id, item_id)
+        # self.assertIsNotNone(topology)
+        # self.assertIn("sources", topology)
+        # self.assertIn("destinations", topology)
+
+        # destination = fcc.get_eventstream_destination(workspace_id, item_id, destination_id)
+        # self.assertIsNotNone(destination)
+        # self.assertEqual(destination["id"], destination_id)
+
+        # destination_conn = fcc.get_eventstream_destination_connection(workspace_id, item_id, custom_destination_id)
+        # self.assertIsNotNone(destination_conn)
+        # self.assertIn("fullyQualifiedNamespace", destination_conn)
+
+        # source = fcc.get_eventstream_source(workspace_id, item_id, source_id)
+        # self.assertIsNotNone(source)
+        # self.assertEqual(source["id"], source_id)
+
+        # source_conn = fcc.get_eventstream_source_connection(workspace_id, item_id, custom_source_id)
+        # self.assertIsNotNone(source_conn)
+        # self.assertIn("fullyQualifiedNamespace", source_conn)
+
+        # resp = fcc.pause_eventstream(workspace_id, item_id)
+        # self.assertEqual(resp, 200)
+
+        # def resume():
+        #     resp = fcc.resume_eventstream(workspace_id, item_id, start_type="Now")
+        #     self.assertEqual(resp, 200)
+
+        # for _ in range(12):
+        #     try:
+        #         resume()
+        #         break
+        #     except Exception as e:
+        #         sleep(5)
+        
+        # resp = fcc.pause_eventstream_source(workspace_id, item_id, source_id)
+        # self.assertEqual(resp, 200)
+
+        # resp = fcc.pause_eventstream_destination(workspace_id, item_id, destination_id)
+        # self.assertEqual(resp, 200)
+
+        # resp = fcc.resume_eventstream_source(workspace_id, item_id, source_id, start_type="Now")
+        # self.assertEqual(resp, 200)
+
+        # def resume():
+        #     resp = fcc.resume_eventstream_destination(workspace_id, item_id, destination_id, start_type="Now")
+        #     self.assertEqual(resp, 200)
+        
+        # for _ in range(12):
+        #     try:
+        #         resume()
+        #         break
+        #     except Exception as e:
+        #         sleep(5)
+
+

msfabricpysdkcore/tests/test_folders.py

@@ -0,0 +1,53 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_folders(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        folder_id = "d4f3a9fb-6975-4f5c-9c6b-ca205280966f"
+
+        folder = fcc.create_folder(workspace_id=workspace_id, display_name="sdk_sub_folder", parent_folder_id=folder_id)
+        self.assertIsNotNone(folder)
+        self.assertEqual(folder.display_name, "sdk_sub_folder")
+
+        folder_ = fcc.get_folder(workspace_id=workspace_id, folder_id=folder.id)
+        self.assertEqual(folder.id, folder_.id)
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+        folders = [folder for folder in folders if folder.display_name == "sdk_sub_folder"]
+        self.assertGreater(len(folders), 0)
+
+        folder = fcc.update_folder(workspace_id=workspace_id, folder_id=folder.id, display_name="sdk_sub_folder_updated")
+        self.assertEqual(folder.display_name, "sdk_sub_folder_updated")
+
+        folder = fcc.move_folder(workspace_id=workspace_id, folder_id=folder.id)
+        self.assertEqual(folder.display_name, "sdk_sub_folder_updated")
+        self.assertEqual(folder.parent_folder_id, "")
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+
+        for f in folders:
+            if f.display_name != "sdk_folder":
+                f.delete()
+
+        folders = fcc.list_folders(workspace_id=workspace_id)
+        self.assertEqual(len(folders), 1)
+
+
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_tags.py

@@ -0,0 +1,28 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_tags(self):
+        fcc = self.fcc
+
+        tags = fcc.list_tags()
+
+        self.assertIsInstance(tags, list)
+        self.assertGreater(len(tags), 0)
+        sdk_tag = [tag for tag in tags if tag['displayName'] == 'sdk_tag'][0]
+        self.assertIsNotNone(sdk_tag)
+
+        resp = fcc.unapply_tags("05bc5baa-ef02-4a31-ab20-158a478151d3", "a9e59ec1-524b-49b1-a185-37e47dc0ceb9", [sdk_tag["id"]])
+        self.assertEqual(resp, 200)
+        resp = fcc.apply_tags("05bc5baa-ef02-4a31-ab20-158a478151d3", "a9e59ec1-524b-49b1-a185-37e47dc0ceb9", [sdk_tag["id"]])
+        self.assertEqual(resp, 200)
+
+

msfabricpysdkcore/tests/test_variable_libary.py

@@ -0,0 +1,61 @@
+
+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_variable_librarys(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "0812f094-1a5a-4b2a-aba2-e764af2709ec"
+
+        variable_librarys = fcc.list_variable_libraries(workspace_id=workspace_id)
+        for variable_library in variable_librarys:
+            if variable_library.id != item_id:
+                resp = fcc.delete_variable_library(workspace_id=workspace_id, variable_library_id=variable_library.id)
+                self.assertEqual(resp, 200)
+
+        variable_library_definition = fcc.get_variable_library_definition(workspace_id=workspace_id, variable_library_id=item_id)
+        self.assertIn("definition", variable_library_definition)
+        definition = variable_library_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"variablelibrary{date_str}"
+
+        variable_library_new = fcc.create_variable_library(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(variable_library_new.display_name, date_str)
+
+        variable_library_get = fcc.get_variable_library(workspace_id=workspace_id, variable_library_id=variable_library_new.id)
+        self.assertEqual(variable_library_get.display_name, date_str)
+
+        variable_librarys = fcc.list_variable_libraries(workspace_id=workspace_id)
+        self.assertEqual(len(variable_librarys), 2)
+
+        date_str_updated = date_str + "_updated"
+        variable_library_updated = fcc.update_variable_library(workspace_id=workspace_id, variable_library_id=variable_library_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(variable_library_updated.display_name, date_str_updated)
+
+        variable_library_updated = fcc.update_variable_library_definition(workspace_id=workspace_id, variable_library_id=variable_library_new.id, definition=definition)
+        self.assertIn(variable_library_updated.status_code, [200, 202])
+
+        for variable_library in variable_librarys:
+            if variable_library.id != item_id:
+                resp = fcc.delete_variable_library(workspace_id=workspace_id, variable_library_id=variable_library.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+