From 3c418ea22a46acdade01a830c9fa87442e34efd2 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 02:28:52 +0530 Subject: [PATCH 01/22] Update README.md --- README.md | 113 ++++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 96 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 5c0ef2d..d19ca5f 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,6 @@ +# What is Zenduty?? +Zenduty is a cutting edge platform for incident management. With high level automation, Zenduty enables faster and better incident resolution keeping developers first. + # Zenduty Python SDK Python SDK to communicate with zenduty endpoints @@ -5,14 +8,15 @@ Python SDK to communicate with zenduty endpoints ## Installing Installation can be done through pip, as follows: -``` +```sh $ pip install zenduty-api ``` -or you may grab the latest source code from GitHub: -``` +or you may grab the latest source code from GitHub: +```sh $ git clone https://github.com/Zenduty/zenduty-python-sdk $ python3 setup.py install ``` + ## Contents 1) zenduty/api : contains the functions to communicate with zenduty API endpoints 2) zenduty/ : contains the common required files @@ -21,25 +25,100 @@ $ python3 setup.py install ## Getting started Before you begin making use of the SDK, make sure you have your Zenduty Access Token. - You can then import the package into your python script. -``` + +First of all, start off by making a client which connects to Zenduty using API Token. And create a team, most of the operations we'd do start off by creating a team, and creating services. For now, we will start off with creating an instance of a team. + +```python import zenduty + +class SDKTestingClient: + def __init__(self): + self.cred = ZendutyCredential("") + self.client = ZendutyClient( + credential=self.cred, use_https=True + ) # defaults to default service endpoint zenduty.com + +@pytest.mark.teams +class SDKTeamsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.teams_client = TeamsClient(client=self.client) + self.team_member_id = "773c69f5-78f2-42ca-b3d9-b" # Random member id. + self.invite_url = "https://zenduty.com/api/invite/accept/" + self.test_team_name = f"Team - {self.datetime_timestamp}" + + def create_team(self): + create_team = self.teams_client.create_team(self.test_team_name) + return create_team ``` -Based on the endpoint you want to communicate with, create an object of the required class. For example, to create an incident: + +It is important to note that each function returns a urllib3.response.HTTPResponse object. + + +## Account Member +This object represents an account user. Each account member object has a role, which can be "owner," "admin," or "user." An account can have only one owner, but multiple admins and users. + +Prerequisite: A team must be created, where the role of each member can be assigned. + +#### GET - Invite a member to the team +#### Invite a member to the team. +```python +class SDKAccountMembersClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + + def test_account_members_invite(self): + test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + + account_member_invite = self.account_member_client.invite( + team_id = "", # UUID, which is unique_id of the team + first_name="John", + last_name="doe", + role=3, + email=test_email, + ) ``` -api_obj = zenduty.IncidentsApi(zenduty.ApiClient('your-access-token')) -body = {"service":"c7fff4c5-2def-41e8-9120-c63f649a825c", - "escalation_policy":"a70244c8-e343-4dd0-8d87-2f767115568a", - "user":null, - "title":"Name of trial", - "summary":"summary of trial"} -response = api_obj.create_incident(body) -print(response.data) -print(response.status_code) + +#### PATCH - Update Account Member +```python +update_account_member = self.account_member_client.update_account_member( + account_member_username="", + first_name=test_first_name, + last_name=f"Doe {random.randint(2,10000000000000000000000)}", + role=2, +) ``` -Refer the comments under each function for a detailed description of it's parameters. -It is important to note that each function returns a urllib3.response.HTTPResponse object. + +#### GET - Get Account member +#### Get details about a particular team member +````python +account_member = self.account_member_client.get_account_member( + account_member_id="" + ) +```` + + +#### GET - Get all the members of a team +#### Get details of all the members of the team. + +````python +account_members = self.account_member_client.get_all_members() +```` + + +#### DELETE - Delete an Account member +#### Delete a particular member of the team. + + +````python +delete_account_member = self.account_member_client.delete_account_member(account_member_id="") +```` + + + ## Running tests From 224863e13a94f70109a18c9429515563221d8a89 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 03:14:03 +0530 Subject: [PATCH 02/22] Update README.md --- README.md | 105 ++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 99 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index d19ca5f..17863e9 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,10 @@ You can then import the package into your python script. First of all, start off by making a client which connects to Zenduty using API Token. And create a team, most of the operations we'd do start off by creating a team, and creating services. For now, we will start off with creating an instance of a team. + +The Approach here is to make clients here, every module will get a new client to make things simpler and easier for us to understand. + + ```python import zenduty @@ -38,22 +42,50 @@ class SDKTestingClient: self.client = ZendutyClient( credential=self.cred, use_https=True ) # defaults to default service endpoint zenduty.com +``` + +It is important to note that each function returns a urllib3.response.HTTPResponse object. -@pytest.mark.teams + +## Teams +This object represents a team of the account. It lets you create different independent operational units in the account. You can check out the team docs here https://docs.zenduty.com/docs/teams. + +A Team can have multiple Members, Services, Integrations, Schedules, Escalation Policies, Priorities, Maintenance, etc.. + + +#### POST - Create a new team +````python class SDKTeamsClient(SDKTestingClient): def __init__(self): super().__init__() self.teams_client = TeamsClient(client=self.client) - self.team_member_id = "773c69f5-78f2-42ca-b3d9-b" # Random member id. + self.team_member_id = "" # Random member id. self.invite_url = "https://zenduty.com/api/invite/accept/" self.test_team_name = f"Team - {self.datetime_timestamp}" def create_team(self): create_team = self.teams_client.create_team(self.test_team_name) return create_team -``` +```` -It is important to note that each function returns a urllib3.response.HTTPResponse object. +#### GET - List Teams +#### Will fetch all the teams present in that account +````python +list_teams = self.teams_client.list_teams() +```` + +#### PATCH - Update teams +#### Update the team +````python +update_teams = self.teams_client.update_team( + , name="Updated Team Name" + ) +```` + +#### DEL - Delete team +````python +delete_teams = self.teams_client.delete_team() +```` ## Account Member @@ -70,7 +102,7 @@ class SDKAccountMembersClient(SDKTeamsClient): self.teams_client = TeamsClient(client=self.client) self.account_member_client = AccountMemberClient(client=self.client) - def test_account_members_invite(self): + def account_members_invite(self): test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" account_member_invite = self.account_member_client.invite( @@ -109,7 +141,7 @@ account_members = self.account_member_client.get_all_members() ```` -#### DELETE - Delete an Account member +#### DEL - Delete an Account member #### Delete a particular member of the team. @@ -118,6 +150,67 @@ delete_account_member = self.account_member_client.delete_account_member(account ```` +## Account Roles + +#### POST - Create Account Role +#### There are a list of permissions you could give to a role. Please refer to these docs, https://apidocs.zenduty.com/#tag/Account-Custom-Role. + +````python +class SDKAccountRolesClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.account_role_client = AccountRoleClient(client=self.client) + + def create_account_role(self): + test_name = f"Account Role - {self.datetime_timestamp}" + create_account_role = self.account_role_client.create_account_role( + name=test_name, + description="Account Role Description", + permissions=["sla_read"], + ) +```` +#### GET - Get an Account Role +````python +get_account_role = self.account_role_client.get_account_role( + account_role_id= + ) +```` +#### GET - Get a list of roles +````python +list_account_roles = self.account_role_client.list_account_roles() +```` +#### PATCH - Update an Account Role +````python +test_name = f"Updated Account Role - {self.datetime_timestamp}" + update_account_role = self.account_role_client.update_account_role( + account_role_id=, + name=test_name, + description="Updated Account Role Description", + permissions=["sla_read"], + ) +```` +#### DEL - Delete an Account Role +````python +delete_account_role = self.account_role_client.delete_account_role( + account_role_id= + ) +```` + +## Global Event Router +## Events +## Escalation Policy +## Schedules +## Maintenance +## Incidents +## Postmortem +## Priorities +## Roles +## Services +## Integrations +## SLA +## Tags +## Task templates + ## Running tests From 6457d9bf9231b1455e5fef86abb9c8a4f1a5e973 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 03:57:57 +0530 Subject: [PATCH 03/22] Update README.md --- README.md | 219 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 207 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 17863e9..b299512 100644 --- a/README.md +++ b/README.md @@ -67,13 +67,11 @@ class SDKTeamsClient(SDKTestingClient): create_team = self.teams_client.create_team(self.test_team_name) return create_team ```` - #### GET - List Teams #### Will fetch all the teams present in that account ````python list_teams = self.teams_client.list_teams() ```` - #### PATCH - Update teams #### Update the team ````python @@ -81,7 +79,6 @@ update_teams = self.teams_client.update_team( , name="Updated Team Name" ) ```` - #### DEL - Delete team ````python delete_teams = self.teams_client.delete_team() @@ -113,7 +110,6 @@ class SDKAccountMembersClient(SDKTeamsClient): email=test_email, ) ``` - #### PATCH - Update Account Member ```python update_account_member = self.account_member_client.update_account_member( @@ -123,7 +119,6 @@ update_account_member = self.account_member_client.update_account_member( role=2, ) ``` - #### GET - Get Account member #### Get details about a particular team member ````python @@ -131,20 +126,13 @@ account_member = self.account_member_client.get_account_member( account_member_id="" ) ```` - - #### GET - Get all the members of a team #### Get details of all the members of the team. - ````python account_members = self.account_member_client.get_all_members() ```` - - #### DEL - Delete an Account member #### Delete a particular member of the team. - - ````python delete_account_member = self.account_member_client.delete_account_member(account_member_id="") ```` @@ -197,9 +185,216 @@ delete_account_role = self.account_role_client.delete_account_role( ```` ## Global Event Router + +Global Event Router is a webhook, when sent requests to it, would navigate it to a particular integration, to a particular request, if matched with the alert rules defined, would raise an alert. + +Refer to this, for more information, https://apidocs.zenduty.com/#tag/Global-Router. + +#### POST - Create Router +````python +class SDKGERClients(SDKTestingClient): + def __init__(self): + super().__init__() + self.router_client = RouterClient(client=self.client) + self.router_name = f"Router - {self.datetime_timestamp}" + + def create_router(self): + create_router = self.router_client.create_router( + name=self.router_name, + description="Router Description", + ) +```` +#### GET - List Routers +````python +list_router = self.router_client.get_all_routers() +```` +#### GET - Get Router by ID +````python +find_router = self.router_client.get_router_by_id(router_id=) +```` +#### PATCH - Update a particular Router +````python +update_router = self.router_client.update_router( + , + name="Updated Router Name", + description="Updated Router Description", +) +```` +#### DEL - Delete a particular Router +````python +delete_router = self.router_client.delete_router() +```` + ## Events +This object represents the events of an integration. + +#### POST - Create an Event +````python +class SDKEventsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.event_client = EventClient(client=self.client) + self.event_name = f"Event - {self.datetime_timestamp}" + + def get_router_client(self): + get_router = self.event_client.get_router_client() + + def test_create_event(self): + create_event = self.event_client.create_event( + integration_key=, + alert_type="info", + message="This is info alert", + summary="This is the incident summary111", + entity_id=123455, + payload={ + "status": "ACME Payments are failing", + "severity": "1", + "project": "kubeprod", + }, + urls=[ + { + "link_url": "https://www.example.com/alerts/12345/", + "link_text": "Alert URL", + } + ], + ) + +```` + ## Escalation Policy +Escalation policies dictate how an incident created within a service escalates within your team. + +#### POST - Create an Escalation Policy +````python +class SDKEscalationPolicyClient(SDKTeamsClient): + # Inheriting a few methods from the Teams Object. + def __init__(self): + super().__init__() + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="" + ) + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( + self.team_by_id + ) + self.ep_name = f"EP - {self.datetime_timestamp}" + + def create_escalation_policy(self): + + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": "3544118d-fbf5-41e5-ae6c-5"} + ], + "position": 1, + } + ] + create_escalation_policy = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) + +```` +#### GET - Get Escalation Policies by ID +````python +self.escalation_policy_client.get_esp_by_id( + esp_id= +) +```` +#### POST - Update Escalation Policy +````python +update_esp = self.escalation_policy_client.update_esp( + esp=, + name="Test Updated", + rules=self.rule_build, + ) +```` +#### GET - Get all the escalation policies +````python +all_esp = self.escalation_policy_client.get_all_policies() +```` +#### DEL - Delete an Escalation Policy +````python +delete_esp = self.escalation_policy_client.delete_esp(esp=) +```` + ## Schedules +#### POST - Create an Escalation Policy +````python +class SDKSchedulesClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="" + ) + self.schedules_client = self.teams_client.get_schedule_client(self.team_by_id) + self.schedules_name = f"Schedules - {self.datetime_timestamp}" + self.layers = [ + { + "name": "Layer 1", + "is_active": True, + "restriction_type": 0, + "restrictions": [], + "rotation_start_time": "2025-07-29T03:30:00.000Z", + "rotation_end_time": None, + "shift_length": 86400, + "users": [ + { + "user": "", + "position": 1, + } + ], + } + ] + + self.overrides = [ + { + "name": "", + "user": "", + "start_time": "2024-07-29T11:54:34.745000Z", + "end_time": "2024-07-29T18:29:59.999000Z", + } + ] + + def create_schedule(self): + create_schedule = self.schedules_client.create_schedule( + name=self.schedules_name, + timezone="Asia/Kolkata", + layers=self.layers, + overrides=self.overrides, + ) + +```` +#### GET - Get all Schedules +````python +get_all_schedules = self.schedules_client.get_all_schedules() +```` +#### GET - Get Schedules by ID +````python +self.get_schedule_by_id = self.schedules_client.get_schedule_by_id( + schedule_id= + ) +```` +#### POST - Update a Schedule +````python +update_schedule = self.schedules_client.update_schedule( + schedule=, + name="Test Schedule Updated", + ) +```` +#### DEL - Delete a Schedule +````python +delete_schedule = self.schedules_client.delete_schedule( + schedule= + ) +```` + ## Maintenance ## Incidents ## Postmortem From 4f64a7e527fbaa16656c5f804ca9e3f1bc901839 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 05:12:33 +0530 Subject: [PATCH 04/22] Updated docs for V2 SDK. --- README.md | 456 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 444 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index b299512..bb9e6a0 100644 --- a/README.md +++ b/README.md @@ -59,7 +59,7 @@ class SDKTeamsClient(SDKTestingClient): def __init__(self): super().__init__() self.teams_client = TeamsClient(client=self.client) - self.team_member_id = "" # Random member id. + self.team_member_id = # Random member id. self.invite_url = "https://zenduty.com/api/invite/accept/" self.test_team_name = f"Team - {self.datetime_timestamp}" @@ -103,7 +103,7 @@ class SDKAccountMembersClient(SDKTeamsClient): test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" account_member_invite = self.account_member_client.invite( - team_id = "", # UUID, which is unique_id of the team + team_id = , # UUID, which is unique_id of the team first_name="John", last_name="doe", role=3, @@ -113,7 +113,7 @@ class SDKAccountMembersClient(SDKTeamsClient): #### PATCH - Update Account Member ```python update_account_member = self.account_member_client.update_account_member( - account_member_username="", + account_member_username=, first_name=test_first_name, last_name=f"Doe {random.randint(2,10000000000000000000000)}", role=2, @@ -123,7 +123,7 @@ update_account_member = self.account_member_client.update_account_member( #### Get details about a particular team member ````python account_member = self.account_member_client.get_account_member( - account_member_id="" + account_member_id= ) ```` #### GET - Get all the members of a team @@ -134,7 +134,7 @@ account_members = self.account_member_client.get_all_members() #### DEL - Delete an Account member #### Delete a particular member of the team. ````python -delete_account_member = self.account_member_client.delete_account_member(account_member_id="") +delete_account_member = self.account_member_client.delete_account_member(account_member_id=) ```` @@ -275,7 +275,7 @@ class SDKEscalationPolicyClient(SDKTeamsClient): self.account_member_client = AccountMemberClient(client=self.client) self.team_ids.append(self.create_team(self)) self.team_by_id = self.teams_client.find_team_by_id( - team_id="" + team_id= ) self.escalation_policy_client = self.teams_client.get_escalation_policy_client( self.team_by_id @@ -331,7 +331,7 @@ class SDKSchedulesClient(SDKTeamsClient): self.teams_client = TeamsClient(client=self.client) self.team_ids.append(self.create_team(self)) self.team_by_id = self.teams_client.find_team_by_id( - team_id="" + team_id= ) self.schedules_client = self.teams_client.get_schedule_client(self.team_by_id) self.schedules_name = f"Schedules - {self.datetime_timestamp}" @@ -346,7 +346,7 @@ class SDKSchedulesClient(SDKTeamsClient): "shift_length": 86400, "users": [ { - "user": "", + "user": , "position": 1, } ], @@ -356,7 +356,7 @@ class SDKSchedulesClient(SDKTeamsClient): self.overrides = [ { "name": "", - "user": "", + "user": , "start_time": "2024-07-29T11:54:34.745000Z", "end_time": "2024-07-29T18:29:59.999000Z", } @@ -396,22 +396,454 @@ delete_schedule = self.schedules_client.delete_schedule( ```` ## Maintenance + +#### POST - Create a Maintenance +````python +class SDKMaintenanceClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id= + ) + self.maintenance_client = self.teams_client.get_maintenance_client( + self.team_by_id + ) + self.maintenance_name = f"Maintenance Mode - {self.datetime_timestamp}" + + def create_maintenance(self): + create_maintenance = self.maintenance_client.create_team_maintenance( + name=self.maintenance_name, + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=[list], + ) +```` +#### GET - Get all Maintenances +````python +get_maintenance_by_id = self.maintenance_client.get_maintenance_by_id( + maintenance_id= + ) +```` +#### PATCH - Update a Maintenance +````python +update_maintenance = self.maintenance_client.update_maintenance( + maintenance_id=, + name="Updated Maintenance Name", + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=[list], + ) +```` +#### DEL - Delete a Maintenance +````python +delete_maintenance = self.maintenance_client.delete_maintenance( + maintenance_id=unique_id of a maintenance> + ) +```` + ## Incidents +What is an Incident?? + +An incident on Zenduty is an event that is not part of usual operations, and that disrupts operational processes within a Service that is owned by a team. Incidents can be automatically created by an alert integration within the service or manually by a user. + +An incident on Zenduty has three states: + +Triggered: Triggered is the first state of the incident. Zenduty will continue escalating the alert, depending on the escalation policy, as long as the incident is in the Triggered state. +Acknowledged: When an incident is acknowledged by a user, Zenduty stops all further escalations. +Resolved: Marking an incident as resolved implies that the incident has been remediated. Incidents can be resolved automatically by the service integration that created it, or manually by a user. + +#### POST - Create an Incident +````python +class SDKIncidentsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.incident_client = IncidentClient(client=self.client) + self.incident_name = f"Incident - {self.datetime_timestamp}" + self.incident_notes = f"Incident Notes - {self.datetime_timestamp}" + self.incident_tags = f"Incident Tags - {self.datetime_timestamp}" + + def create_incident(self): + create_incident = self.incident_client.create_incident( + title=self.incident_name, service= + ) + +```` +#### POST - Create an Incident Note +````python + self.note_client = self.incident_client.get_note_client( + incident_id= + ) + + # Creating an incident note, attaching it to an incident + create_incident_note = self.note_client.create_incident_note( + note=self.incident_notes + ) +```` +#### GET - Get all Incident Notes +````python +get_all_incident_notes = self.note_client.get_all_incident_notes() +```` +#### GET - Get Incident note by id +````python + get_incident_note_by_id = self.note_client.get_incident_note_by_id( + incident_note_unique_id= + ) +```` +#### PATCH - Update an Incident note +````python +update_incident_note = self.note_client.update_incident_note( + incident_note_unique_id=, + note="Updated Incident Note", + ) +```` +#### DEL - Delete an Incident note +````python + delete_incident_note = self.note_client.delete_incident_note( + incident_note_unique_id= + ) +```` +#### POST - Create an Incident Tag +````python + self.tag_client = self.incident_client.get_tags_client() + + create_incident_tag = self.tag_client.create_tag( + team_tag= + ) +```` +#### GET - Get all Incident Tags +````python +get_all_tags = self.tag_client.get_all_tags() +```` +#### GET - Get all Incidents +````python +get_all_incidents = self.incident_client.get_all_incidents(page=1) +```` +#### GET - Get Alerts of Incidents +````python +get_alerts_by_incident = self.incident_client.get_alerts_for_incident( + incident_number + ) +```` +#### PATCH - Update an Incident +````python +update_incident = self.incident_client.update_incident( + incident_id=, + title="Updated Incident Name", + status=3, + service="a91a3a00-8de9-472c-ad2e-61e7c89db062", + ) +```` + ## Postmortem +#### POST - Create a Postmortem +````python +class SDKPostMortemClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.incident_name = "blahblah" + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id= + ) + self.incident_client = IncidentClient(client=self.client) + self.incident_name = f"Incident - {self.datetime_timestamp}" + self.postmortem_client = self.teams_client.get_postmortem_client( + self.team_by_id + ) + self.postmortem_name = f"Postmortem - {self.datetime_timestamp}" + + def create_postmortem(self): + # Create the Incident + create_incident = self.incident_client.create_incident( + title=self.incident_name, service= + ) + + # Create the Postmortem + create_postmortem = self.postmortem_client.create_postmortem( + author=, + incidents=[list], + title="Test Postmortem", + ) + +```` +#### GET - Get postmortem by id +````python +self.postmortem_by_id = self.postmortem_client.get_postmortem_by_id( + postmortem_id= + ) +```` +#### PATCH - Update a postmortem +````python +pdate_postmortem = self.postmortem_client.update_postmortem( + , + author=, + incidents=[list], + title="Test Postmortem Updated", + ) +```` +#### DEL - Delete a postmortem +````python +delete_postmortem = self.postmortem_client.delete_postmortem( + + ) +```` + ## Priorities +#### POST - Create a priority +````python +class SDKPrioritiesClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id= + ) + self.priority_client = self.teams_client.get_priority_client(self.team_by_id) + self.priority_name = f"Priority - {self.datetime_timestamp}" + + def create_priority(self): + create_priority = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) + +```` +#### GET - Get all priorities +````python +get_all_priorities = self.priority_client.get_all_priorities() +```` +#### GET - Get priorities by ID +````python +self.priority_by_id = self.priority_client.get_priority_by_id( + priority_id= + ) +```` +#### PATCH - Update the priority +````python +update_priority = self.priority_client.update_priority( + , + name="Test Priority Updated", + description="Test Priority", + ) +```` +#### DEL - Delete a priority +````python +delete_priority = self.priority_client.delete_priority() +```` + ## Roles +#### POST - Create a Role +````python +class SDKRolesClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id= + ) + self.role_client = self.teams_client.get_incident_role_client(self.team_by_id) + self.role_name = f"Role - {self.datetime_timestamp}" + + def create_role(self): + self.create_role = self.role_client.create_incident_role( + title="Test Role", + description="Test Role", + rank=1, + ) +```` +#### GET - Get incident role by id +````python + self.get_role_by_id = self.role_client.get_incident_role_by_id( + role_id= + ) +```` +#### PATCH - Update an incident role +````python +self.update_role = self.role_client.update_incident_role( + role=, + title="Test Role Updated", + ) +```` +#### DEL - Delete an incident role +````python +self.delete_role = self.role_client.delete_incident_role( + role= + ) +```` + ## Services +#### POST - Create a Service +````python +class SDKServicesClient(SDKTeamsClient): + def __init__(self): + super().__init__() + # Making the Teams Client + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + # Making the Service Client + self.service_client = self.teams_client.get_service_client(self.team_ids[0]) + self.team_by_id = self.teams_client.find_team_by_id( + team_id= + ) + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( + self.team_by_id + ) + self.priority_client = self.teams_client.get_priority_client(self.team_by_id) + self.sla_client = self.teams_client.get_sla_client(self.team_by_id) + # Making the names + self.ep_name = f"EP - {self.datetime_timestamp}" + self.priority_name = f"Priority - {self.datetime_timestamp}" + self.sla_name = f"SLA - {self.datetime_timestamp}" + self.service_name = f"Service - {self.datetime_timestamp}" + + def test_create_service(self): + # Create the escalation policy + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": } + ], + "position": 1, + } + ] + create_escalation_policy = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) + + + # Create the Priority + create_priority = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) + + # Create the SLA + create_sla = self.sla_client.create_sla(name="Test SLA", escalations=[]) + + # Finally create the service + create_service = self.service_client.create_service( + name=f"Test Service - {self.datetime_timestamp}", + escalation_policy=, + team_priority=, + sla=, + ) +```` + ## Integrations +#### POST - Create an integration +````python +integration_client = service_client.get_integration_client(svc=) + +create_integration = integration_client.create_intg( name="Test Integration", summary="Test Integration", application=) + +```` +#### GET - Get all integrations +````python +all_integrations = integration_client.get_all_integrations() +```` +#### GET - Get integration by id +````python +integration_by_id = integration_client.get_intg_by_id(intg=) +```` +#### PATCH - Update an integration +````python +update_integration = integration_client.update_intg(intg=, name="Test Integration Updated", application=) +```` +#### DEL - Delete an integration +````python +delete_integration = integration_client.delete_intg(intg=) +```` + ## SLA +#### POST - Create an SLA +````python +sla_client = team_client.get_sla_client(team_by_id) +create_sla = sla_client.create_sla(name="Test SLA", escalations=[]) +```` +#### GET - Get SLA by id +````python +sla_by_id = sla_client.get_sla_by_id(sla_id=) +```` +#### PATCH - Update SLA +````python +update_sla = sla_client.update_sla(sla=, name="Test SLA Updated", escalations=[]) +```` +#### DEL - Delete SLA +````python +delete_sla sla_client.delete_sla(sla=) +```` + ## Tags +#### POST - Create a tag +````python +tag_client = team_client.get_tag_client(team_by_id) +create_tag = tag_client.create_tag(name="TestXsadasd", color="red") +```` +#### GET - Get all tags +````python +get_all_tags = tag_client.get_all_tags() +```` +#### GET - GET tag by id +````python +get_tag = tag_client.get_tag_by_id(tags_id = ) +```` +#### PATCH - Update tag by id +````python +update_tag = tag_client(tag = , name="updated name", color="green") +```` +#### DEL - Delete tag +````python +delete_tag = tag_client(tag = ) +```` + + ## Task templates +#### POST - Create a task template +````python +task_template_client = team_client.get_task_template_client(team_by_id) +create_task_template = task_template_client.create_task_template( + name="Test Task Template", summary="Test Task Template" +) +```` +#### GET - Get all task templates +````python +get_all_task_templates = task_template_client.get_all_task_template() +```` +#### GET - Get task templates by id +````python +get_task_template_by_id = task_template_client.get_task_template_by_id( + task_template_id= +) +```` +#### PATCH - Update the task template +````python +update_task_template = task_template_client.update_task_template( + task_template = , name="Test Task Template Updated" +) +```` +#### DEL - Delete the task template +````python +delete_task_template = task_template_client.delete_task_template(task_template = ) +```` -## Running tests +# Running tests -There is a sample skeleton code in bin/. Add your access token to it and modify the object and function name for testing purposes. +There is a sample skeleton code in tests/. Add your access token to it and modify the object and function name for testing purposes. -## License +# License This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details From 935451589e26a2fb16325cf400599b09c1fa0980 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 05:14:00 +0530 Subject: [PATCH 05/22] Added Tests folder --- tests/test_sdk_automated.py | 1021 +++++++++++++++++++++++++++++++++++ 1 file changed, 1021 insertions(+) create mode 100644 tests/test_sdk_automated.py diff --git a/tests/test_sdk_automated.py b/tests/test_sdk_automated.py new file mode 100644 index 0000000..fd0581c --- /dev/null +++ b/tests/test_sdk_automated.py @@ -0,0 +1,1021 @@ +import sys +import uuid +import time +import pytest +import random +import string +import zenduty +from pathlib import Path +from datetime import datetime, timedelta + +# Importing V2 Clients +from zenduty.apiV2.client import ZendutyClient + +# Importing V2 Internal Clients +from zenduty.apiV2.teams import TeamsClient +from zenduty.apiV2.events import EventClient +from zenduty.apiV2.incidents import IncidentClient +from zenduty.apiV2.events.router import RouterClient +from zenduty.apiV2.incidents.notes import IncidentNoteClient +from zenduty.apiV2.incidents.tags import IncidentTagClient +from zenduty.apiV2.accounts.roles import AccountRoleClient +from zenduty.apiV2.accounts.members import AccountMemberClient +from zenduty.apiV2.teams.escalation_policies.rules import RuleBuilder +from zenduty.apiV2.teams.escalation_policies.targets import TargetBuilder +from zenduty.apiV2.authentication.zenduty_credential import ZendutyCredential + + +class SDKTestingClient: + def __init__(self): + self.cred = ZendutyCredential("e3464dbec1590e0c226685e156f40ed541c3b715") + self.client = ZendutyClient( + credential=self.cred, use_https=True + ) # defaults to default service endpoint zenduty.com + self.datetime_timestamp = self.datetime_timestamp() + + @staticmethod + def datetime_timestamp(): + return datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + @staticmethod + def generate_uuid() -> str: + # generate a random UUID + return str(uuid.uuid4()) + + +@pytest.mark.teams +class TestSDKTeamsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.team_members = [] + self.team_member_unique_id = [] + self.teams_client = TeamsClient(client=self.client) + self.team_member_id = "773c69f5-78f2-42ca-b3d9-b" + self.invite_url = "https://zenduty.com/api/invite/accept/" + self.test_team_name = f"Team - {self.datetime_timestamp}" + + @staticmethod + def create_team(self): + create_team = self.teams_client.create_team(self.test_team_name) + return create_team + + @staticmethod + def delete_team(self): + delete_team = self.teams_client.delete_team(self.team_ids[0]) + + # Teams testing + def test_create_team(self): + # Team1 is the name of the team and that is the payload + create_team = self.teams_client.create_team(self.test_team_name) + self.team_ids.append(create_team) + assert create_team.name == self.test_team_name + time.sleep(2) + + def test_find_team_by_id(self): + find_team = self.teams_client.find_team_by_id(self.team_ids[0].unique_id) + assert find_team.unique_id == self.team_ids[0].unique_id + time.sleep(2) + + def test_list_team_member(self): + list_team_members = self.teams_client.list_team_members(self.team_ids[0]) + assert list_team_members[0].team == self.team_ids[0].unique_id + time.sleep(2) + + def test_add_team_member(self): + add_team_member = self.teams_client.add_team_member( + self.team_ids[0], username=self.team_member_id + ) + assert str(add_team_member.team) == str(self.team_ids[0].unique_id) + time.sleep(2) + + def test_find_team_member(self): + list_team_members = self.teams_client.list_team_members(self.team_ids[0]) + self.team_member_unique_id.append(list_team_members[1].unique_id) + find_team_member = self.teams_client.find_team_member( + self.team_ids[0], member_unique_id=self.team_member_unique_id[0] + ) + assert str(find_team_member.unique_id) == str(self.team_member_unique_id[0]) + time.sleep(2) + + def test_update_team_member(self): + update_team_member = self.teams_client.update_team_member( + self.team_ids[0], member_id=self.team_member_unique_id[0], role=1 + ) + assert update_team_member.role == 1 and str( + update_team_member.unique_id + ) == str(self.team_member_unique_id[0]) + time.sleep(2) + + def test_delete_team_member(self): + delete_team_member = self.teams_client.delete_team_member( + self.team_ids[0], member_id=self.team_member_unique_id[0] + ) + time.sleep(2) + + def test_fetch_team_permissions(self): + team_permissions = self.teams_client.fetch_team_permissions(self.team_ids[0]) + + def update_team_permissions(self): + updated_team_permissions = self.teams_client.update_team_permissions( + permissions=["service_read"], team=self.team_ids[0] + ) + assert "service_read" in updated_team_permissions + + def test_update_teams(self): + update_teams = self.teams_client.update_team( + self.team_ids[0], name="Updated Team Name" + ) + assert str(update_teams.name) == "Updated Team Name" + + def test_delete_teams(self): + delete_teams = self.teams_client.delete_team(self.team_ids[0]) + + +@pytest.mark.accountmembers +class TestSDKAccountMembersClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.account_member_ids = [] + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + + def test_account_members_invite(self): + create_team = self.teams_client.create_team( + name="Random Testing Team" + self.datetime_timestamp + ) + self.team_ids.append(create_team.unique_id) + + test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + + account_member_invite = self.account_member_client.invite( + team_id=self.team_ids[0], + first_name="John", + last_name="doe", + role=3, + email=test_email, + ) + self.account_member_ids.append(account_member_invite.user.username) + assert account_member_invite.user.email == test_email + + def test_account_member_update(self): + test_first_name = f"Jane {random.randint(2,10000000000000000000000)}" + # updated the email + update_account_member = self.account_member_client.update_account_member( + account_member_username=self.account_member_ids[0], + first_name=test_first_name, + last_name=f"Doe {random.randint(2,10000000000000000000000)}", + role=2, + ) + + assert update_account_member.user.first_name == test_first_name + + def test_get_account_member(self): + account_member = self.account_member_client.get_account_member( + account_member_id=self.account_member_ids[0] + ) + assert account_member.user.username == self.account_member_ids[0] + + def test_get_all_account_members(self): + account_members = self.account_member_client.get_all_members() + + def test_delete_account_member(self): + delete_account_member = self.account_member_client.delete_account_member( + account_member_id=self.account_member_ids[0] + ) + + +@pytest.mark.accountroles +class TestSDKAccountRolesClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.account_role_ids = [] + self.account_role_client = AccountRoleClient(client=self.client) + + def test_create_account_role(self): + test_name = f"Account Role - {self.datetime_timestamp}" + create_account_role = self.account_role_client.create_account_role( + name=test_name, + description="Account Role Description", + permissions=["sla_read"], + ) + + self.account_role_ids.append(create_account_role.unique_id) + + assert create_account_role.name == test_name + + time.sleep(2) + + def test_get_account_role(self): + get_account_role = self.account_role_client.get_account_role( + account_role_id=self.account_role_ids[0] + ) + + assert str(get_account_role.unique_id) == str(self.account_role_ids[0]) + time.sleep(2) + + def test_list_account_roles(self): + list_account_roles = self.account_role_client.list_account_roles() + time.sleep(2) + + def test_update_account_role(self): + test_name = f"Updated Account Role - {self.datetime_timestamp}" + update_account_role = self.account_role_client.update_account_role( + account_role_id=self.account_role_ids[0], + name=test_name, + description="Updated Account Role Description", + permissions=["sla_read"], + ) + assert update_account_role.name == test_name + time.sleep(2) + + def test_delete_account_role(self): + delete_account_role = self.account_role_client.delete_account_role( + account_role_id=self.account_role_ids[0] + ) + time.sleep(2) + + +@pytest.mark.GER +class TestSDKGERClients(SDKTestingClient): + def __init__(self): + super().__init__() + self.router_ids = [] + self.router_client = RouterClient(client=self.client) + self.router_name = f"Router - {self.datetime_timestamp}" + + def test_create_router(self): + create_router = self.router_client.create_router( + name=self.router_name, + description="Router Description", + ) + self.router_ids.append(create_router.unique_id) + assert str(create_router.name) == f"Router - {self.datetime_timestamp}" + time.sleep(2) + + def test_list_routers(self): + list_router = self.router_client.get_all_routers() + for router in list_router: + if str(router.name) == f"Router - {self.datetime_timestamp}": + assert str(router.name) == f"Router - {self.datetime_timestamp}" + break + time.sleep(2) + + def test_get_router_by_id(self): + find_router = self.router_client.get_router_by_id(router_id=self.router_ids[0]) + assert str(find_router.unique_id) == str(self.router_ids[0]) + time.sleep(2) + + def test_update_router(self): + update_router = self.router_client.update_router( + self.router_ids[0], + name="Updated Router Name", + description="Updated Router Description", + ) + assert str(update_router.name) == "Updated Router Name" + + time.sleep(2) + + def test_delete_router(self): + delete_router = self.router_client.delete_router(self.router_ids[0]) + time.sleep(2) + + +@pytest.mark.events +class TestSDKEventsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.event_ids = [] + self.event_client = EventClient(client=self.client) + self.event_name = f"Event - {self.datetime_timestamp}" + + def test_get_router_client(self): + get_router = self.event_client.get_router_client() + + def test_create_event(self): + + create_event = self.event_client.create_event( + integration_key="f86e6ade-f987-4cfc-b047-9ce9ca794b41", + alert_type="info", + message="This is info alert", + summary="This is the incident summary111", + entity_id=123455, + payload={ + "status": "ACME Payments are failing", + "severity": "1", + "project": "kubeprod", + }, + urls=[ + { + "link_url": "https://www.example.com/alerts/12345/", + "link_text": "Alert URL", + } + ], + ) + + assert ( + create_event.integration_object.integration_key + == "f86e6ade-f987-4cfc-b047-9ce9ca794b41" + ) + + +@pytest.mark.escalationpolicy +class TestSDKEscalationPolicyClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.escalation_policy_ids = [] + self.account_member_ids = [] + self.team_ids = [] + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( + self.team_by_id + ) + self.ep_name = f"EP - {self.datetime_timestamp}" + + @staticmethod + def generate_uuid() -> str: + return str(uuid.uuid4()) + + def test_create_escalation_policy(self): + + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": "3544118d-fbf5-41e5-ae6c-5"} + ], + "position": 1, + } + ] + create_escalation_policy = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) + + # Appending the unique_id to the escalation_policy_ids list + self.escalation_policy_ids.append(create_escalation_policy.unique_id) + assert create_escalation_policy.name == self.ep_name + time.sleep(2) + + def test_get_esp_by_id(self): + self.get_esp_by_id = self.escalation_policy_client.get_esp_by_id( + esp_id=self.escalation_policy_ids[0] + ) + assert self.get_esp_by_id.name == self.ep_name + time.sleep(2) + + def test_update_esp(self): + update_esp = self.escalation_policy_client.update_esp( + esp=self.get_esp_by_id, + name="Test Updated", + rules=self.rule_build, + ) + + assert update_esp.name == "Test Updated" + time.sleep(2) + + def test_get_all_policies(self): + all_esp = self.escalation_policy_client.get_all_policies() + time.sleep(2) + + def test_delete_esp(self): + delete_esp = self.escalation_policy_client.delete_esp(esp=self.get_esp_by_id) + time.sleep(2) + + +@pytest.mark.maintenance +class TestSDKMaintenanceClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.maintenance_ids = [] + self.account_member_ids = [] + self.team_ids = [] + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.maintenance_client = self.teams_client.get_maintenance_client( + self.team_by_id + ) + self.maintenance_name = f"Maintenance Mode - {self.datetime_timestamp}" + + def test_create_maintenance(self): + create_maintenance = self.maintenance_client.create_team_maintenance( + name=self.maintenance_name, + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=["a91a3a00-8de9-472c-ad2e-61e7c89db062"], + ) + + self.maintenance_ids.append(create_maintenance.unique_id) + assert create_maintenance.name == self.maintenance_name + time.sleep(2) + + def test_get_all_maintenance(self): + get_all_maintenance = self.maintenance_client.get_all_maintenance() + + time.sleep(2) + + def test_get_maintenance_by_id(self): + get_maintenance_by_id = self.maintenance_client.get_maintenance_by_id( + maintenance_id=self.maintenance_ids[0] + ) + + time.sleep(2) + + def test_update_maintenance_by_id(self): + update_maintenance = self.maintenance_client.update_maintenance( + maintenance_id=self.maintenance_ids[0], + name="Updated Maintenance Name", + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=["a91a3a00-8de9-472c-ad2e-61e7c89db062"], + ) + + time.sleep(2) + + def test_delete_maintenance(self): + delete_maintenance = self.maintenance_client.delete_maintenance( + maintenance_id=self.maintenance_ids[0] + ) + + time.sleep(2) + + +@pytest.mark.incidents +class TestSDKIncidentsClient(SDKTestingClient): + def __init__(self): + super().__init__() + self.incident_ids = [] + self.incident_number = [] + self.incident_notes_list = [] + self.incident_tags_list = [] + self.incident_client = IncidentClient(client=self.client) + self.incident_name = f"Incident - {self.datetime_timestamp}" + self.incident_notes = f"Incident Notes - {self.datetime_timestamp}" + self.incident_tags = f"Incident Tags - {self.datetime_timestamp}" + + def test_create_incident(self): + create_incident = self.incident_client.create_incident( + title=self.incident_name, service="a91a3a00-8de9-472c-ad2e-61e7c89db062" + ) + + assert ( + str(create_incident.title) == self.incident_name + and str(create_incident.service) == "a91a3a00-8de9-472c-ad2e-61e7c89db062" + ) + + self.incident_ids.append(create_incident.unique_id) + self.incident_number.append(create_incident.incident_number) + time.sleep(2) + + # check here for incident notes and tags + def test_create_incident_note(self): + # Creating a Incident Note client + self.note_client = self.incident_client.get_note_client( + incident_id=self.incident_ids[0] + ) + + # Creating an incident note, attaching it to an incident + create_incident_note = self.note_client.create_incident_note( + note=self.incident_notes + ) + self.incident_notes_list.append(create_incident_note.unique_id) + + assert str(create_incident_note.note) == self.incident_notes + + time.sleep(2) + + def test_get_all_incident_notes(self): + get_all_incident_notes = self.note_client.get_all_incident_notes() + time.sleep(2) + + def test_get_incident_note_by_id(self): + get_incident_note_by_id = self.note_client.get_incident_note_by_id( + incident_note_unique_id=self.incident_notes_list[0] + ) + time.sleep(2) + + # get this checked tomorrow + def test_update_incident_note(self): + update_incident_note = self.note_client.update_incident_note( + incident_note_unique_id=self.incident_notes_list[0], + note="Updated Incident Note", + ) + + def test_delete_incident_note(self): + delete_incident_note = self.note_client.delete_incident_note( + incident_note_unique_id=self.incident_notes_list[0] + ) + + # get this checked tomorrow + def test_create_incident_tag(self): + self.tag_client = self.incident_client.get_tags_client(self.incident_number[0]) + + create_incident_tag = self.tag_client.create_tag( + team_tag=self.incident_number[0] + ) + + def test_get_all_tags(self): + get_all_tags = self.tag_client.get_all_tags() + + def test_get_tag_by_id(self): + get_tag_by_id = self.tag_client.get_tag_by_id(self.incident_tags[0]) + + def test_delete_incident_tag(self): + delete_incident_tag = self.tag_client.delete_tag(self.incident_tags[0]) + + def test_get_all_incidents(self): + get_all_incidents = self.incident_client.get_all_incidents(page=1) + + for incident in get_all_incidents: + if str(incident["title"]) == self.incident_name: + assert str(incident["title"]) == self.incident_name + break + time.sleep(2) + + def test_get_alerts_by_incident(self): + get_alerts_by_incident = self.incident_client.get_alerts_for_incident( + incident_number=self.incident_number[0] + ) + time.sleep(2) + + def test_update_incident(self): + update_incident = self.incident_client.update_incident( + incident_id=self.incident_ids[0], + title="Updated Incident Name", + status=3, + service="a91a3a00-8de9-472c-ad2e-61e7c89db062", + ) + + assert ( + int(update_incident.status) == 3 + and str(update_incident.title) == "Updated Incident Name" + and str(update_incident.unique_id) == str(self.incident_ids[0]) + and str(update_incident.incident_number) == str(self.incident_number[0]) + ) + + +@pytest.mark.postmortem +class TestSDKPostMortemClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.incident_ids = [] + self.postmortem_ids = [] + self.account_member_ids = [] + self.incident_name = "blahblah" + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.incident_client = IncidentClient(client=self.client) + self.incident_name = f"Incident - {self.datetime_timestamp}" + self.postmortem_client = self.teams_client.get_postmortem_client( + self.team_by_id + ) + self.postmortem_name = f"Postmortem - {self.datetime_timestamp}" + + def test_create_postmortem(self): + # Create the Incident + create_incident = self.incident_client.create_incident( + title=self.incident_name, service="a91a3a00-8de9-472c-ad2e-61e7c89db062" + ) + + # Create the Postmortem + create_postmortem = self.postmortem_client.create_postmortem( + author="3544118d-fbf5-41e5-ae6c-5", + incidents=[create_incident.unique_id], + title="Test Postmortem", + ) + + # Appending the unique id to the postmortem list. + self.postmortem_ids.append(create_postmortem.unique_id) + self.incident_ids.append(create_incident.unique_id) + + def test_get_postmortem_by_id(self): + self.postmortem_by_id = self.postmortem_client.get_postmortem_by_id( + postmortem_id=self.postmortem_ids[0] + ) + + assert self.postmortem_by_id.title == "Test Postmortem" + + def test_update_postmortem(self): + update_postmortem = self.postmortem_client.update_postmortem( + self.postmortem_by_id, + author="3544118d-fbf5-41e5-ae6c-5", + incidents=[self.incident_ids[0]], + title="Test Postmortem Updated", + ) + assert update_postmortem.title == "Test Postmortem Updated" + + def test_delete_postmortem(self): + delete_postmortem = self.postmortem_client.delete_postmortem( + self.postmortem_by_id + ) + + # Resolve the incident + resolve_incident = self.incident_client.update_incident( + incident_id=self.incident_ids[0], + title=self.incident_name, + status=3, + ) + + +@pytest.mark.priorities +class TestSDKPrioritiesClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.priority_ids = [] + self.account_member_ids = [] + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.priority_client = self.teams_client.get_priority_client(self.team_by_id) + self.priority_name = f"Priority - {self.datetime_timestamp}" + + def test_create_priority(self): + create_priority = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) + + self.priority_ids.append(create_priority.unique_id) + assert create_priority.name == self.priority_name + time.sleep(2) + + def test_get_all_priorities(self): + get_all_priorities = self.priority_client.get_all_priorities() + time.sleep(2) + + def test_get_priority_by_id(self): + self.priority_by_id = self.priority_client.get_priority_by_id( + priority_id=self.priority_ids[0] + ) + + assert self.priority_by_id.name == self.priority_name + + def test_update_priority(self): + update_priority = self.priority_client.update_priority( + self.priority_by_id, + name="Test Priority Updated", + description="Test Priority", + ) + + assert update_priority.name == "Test Priority Updated" + time.sleep(2) + + def test_delete_priority(self): + delete_priority = self.priority_client.delete_priority(self.priority_ids[0]) + time.sleep(2) + + +@pytest.mark.roles +class TestSDKRolesClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.role_ids = [] + self.account_member_ids = [] + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.role_client = self.teams_client.get_incident_role_client(self.team_by_id) + self.role_name = f"Role - {self.datetime_timestamp}" + + def test_create_role(self): + self.create_role = self.role_client.create_incident_role( + title="Test Role", + description="Test Role", + rank=1, + ) + + self.role_ids.append(self.create_role.unique_id) + assert self.create_role.title == "Test Role" + time.sleep(2) + + def test_get_incident_role_by_id(self): + self.get_role_by_id = self.role_client.get_incident_role_by_id( + role_id=self.role_ids[0] + ) + assert self.get_role_by_id.title == "Test Role" + time.sleep(2) + + def test_update_incident_role(self): + self.update_role = self.role_client.update_incident_role( + role=self.get_role_by_id, + title="Test Role Updated", + ) + assert self.update_role.title == "Test Role Updated" + time.sleep(2) + + def test_delete_incident_role(self): + self.delete_role = self.role_client.delete_incident_role( + role=self.get_role_by_id + ) + time.sleep(2) + + +@pytest.mark.schedules +class TestSDKSchedulesClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.schedules_ids = [] + self.account_member_ids = [] + self.uuid = self.generate_uuid() + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.schedules_client = self.teams_client.get_schedule_client(self.team_by_id) + self.schedules_name = f"Schedules - {self.datetime_timestamp}" + self.layers = [ + { + "name": "Layer 1", + "is_active": True, + "restriction_type": 0, + "restrictions": [], + "rotation_start_time": "2025-07-29T03:30:00.000Z", + "rotation_end_time": None, + "shift_length": 86400, + "users": [ + { + "user": "3544118d-fbf5-41e5-ae6c-5", + "position": 1, + } + ], + } + ] + + self.overrides = [ + { + "name": "", + "user": "3544118d-fbf5-41e5-ae6c-5", + "start_time": "2024-07-29T11:54:34.745000Z", + "end_time": "2024-07-29T18:29:59.999000Z", + } + ] + + def test_create_schedule(self): + create_schedule = self.schedules_client.create_schedule( + name=self.schedules_name, + timezone="Asia/Kolkata", + layers=self.layers, + overrides=self.overrides, + ) + + self.schedules_ids.append(create_schedule.unique_id) + assert create_schedule.name == self.schedules_name + time.sleep(2) + + def test_get_all_schedules(self): + get_all_schedules = self.schedules_client.get_all_schedules() + time.sleep(2) + + def test_get_schedule_by_id(self): + self.get_schedule_by_id = self.schedules_client.get_schedule_by_id( + schedule_id=self.schedules_ids[0] + ) + + assert self.get_schedule_by_id.name == self.schedules_name + time.sleep(2) + + def test_update_schedule(self): + update_schedule = self.schedules_client.update_schedule( + schedule=self.get_schedule_by_id, + name="Test Schedule Updated", + ) + assert update_schedule.name == "Test Schedule Updated" + + def test_delete_schedule(self): + delete_schedule = self.schedules_client.delete_schedule( + schedule=self.get_schedule_by_id + ) + + +@pytest.mark.services +class TestSDKServicesClient(TestSDKTeamsClient): + def __init__(self): + super().__init__() + self.team_ids = [] + self.sla_ids = [] + self.priority_ids = [] + self.escalation_policy_ids = [] + self.service_ids = [] + # Making the Teams Client + self.teams_client = TeamsClient(client=self.client) + self.team_ids.append(self.create_team(self)) + # Making the Service Client + self.service_client = self.teams_client.get_service_client(self.team_ids[0]) + self.team_by_id = self.teams_client.find_team_by_id( + team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" + ) + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( + self.team_by_id + ) + self.priority_client = self.teams_client.get_priority_client(self.team_by_id) + self.sla_client = self.teams_client.get_sla_client(self.team_by_id) + # Making the names + self.ep_name = f"EP - {self.datetime_timestamp}" + self.priority_name = f"Priority - {self.datetime_timestamp}" + self.sla_name = f"SLA - {self.datetime_timestamp}" + self.service_name = f"Service - {self.datetime_timestamp}" + + def test_create_service(self): + # Create the escalation policy + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": "3544118d-fbf5-41e5-ae6c-5"} + ], + "position": 1, + } + ] + create_escalation_policy = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) + + # Appending the unique_id to the escalation_policy_ids list + self.escalation_policy_ids.append(str(create_escalation_policy.unique_id)) + print("ids", self.escalation_policy_ids) + time.sleep(2) + # Create the Priority + create_priority = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) + + # Appending the unique_id to the priority_ids list + self.priority_ids.append(create_priority.unique_id) + time.sleep(2) + + # Create the SLA + create_sla = self.sla_client.create_sla(name="Test SLA", escalations=[]) + + # Appending the unique_id to the sla_ids list + self.sla_ids.append(create_sla.unique_id) + + time.sleep(2) + + # Finally create the service + create_service = self.service_client.create_service( + name=f"Test Service - {self.datetime_timestamp}", + escalation_policy=self.escalation_policy_ids[0], + team_priority=str(self.priority_ids[0]), + sla=str(self.sla_ids[0]), + ) + + +@pytest.mark.integrations +class TestSDKIntegrationClient(TestSDKServicesClient): + def __init__(self): + super().__init__() + self.service_ids = [] + integration_client = self.service_client.get_integration_client( + svc=self.service_ids[0] + ) + + +@pytest.mark.sla +class TestSDKSLAClient(SDKTestingClient): + pass + + +@pytest.mark.tags +class TestSDKTagsClient(SDKTestingClient): + pass + + +@pytest.mark.tasktemplates +class TestSDKTaskTemplatesClient(SDKTestingClient): + pass + + +if __name__ == "__main__": + # escalations_client = TestSDKEscalationPolicyClient() + # escalations_client.test_create_escalation_policy() + + # teams_client = TestSDKTeamsClient() + # teams_client.test_create_team() + # teams_client.test_find_team_by_id() + # teams_client.test_list_team_member() + # teams_client.test_add_team_member() + # teams_client.test_find_team_member() + # teams_client.test_update_team_member() + # teams_client.test_delete_team_member() + # teams_client.test_fetch_team_permissions() + # teams_client.update_team_permissions() + # teams_client.test_update_teams() + # teams_client.test_delete_teams() + + # router_client = TestSDKGERClients() + # router_client.test_create_router() + # router_client.test_list_routers() + # router_client.test_get_router_by_id() + # router_client.test_update_router() + # router_client.test_delete_router() + + # account_members = TestSDKAccountMembersClient() + # account_members.test_account_members_invite() + # account_members.test_account_member_update() + # account_members.test_get_account_member() + # account_members.test_get_all_account_members() + # account_members.test_delete_account_member() + + # account_role = TestSDKAccountRolesClient() + # account_role.test_create_account_role() + # account_role.test_get_account_role() + # account_role.test_list_account_roles() + # account_role.test_update_account_role() + # account_role.test_delete_account_role() + + # event = TestSDKEventsClient() + # event.test_get_router_client() + # event.test_create_event() + + # incidents = TestSDKIncidentsClient() + # incidents.test_create_incident() + # incidents.test_get_all_incidents() + # incidents.test_get_alerts_by_incident() + # incidents.test_update_incident() + + # incidents.test_create_incident_note() + # incidents.test_get_all_incident_notes() + # # get this checked tomorrow + # # incidents.test_get_incident_note_by_id() + # incidents.test_update_incident_note() + # incidents.test_delete_incident_note() + # # get this checked tomorrow - all of these below + # incidents.test_create_incident_tag() + # incidents.test_get_all_tags() + # incidents.test_get_tag_by_id() + # incidents.test_delete_incident_tag() + + # escalations_client = TestSDKEscalationPolicyClient() + # escalations_client.test_create_escalation_policy() + # escalations_client.test_get_esp_by_id() + # escalations_client.test_update_esp() + # escalations_client.test_get_all_policies() + # escalations_client.test_delete_esp() + + # Run this, and ask what is "Maintenance_Template" + # add Maintenance_Template to the model + # maintenance_client = TestSDKMaintenanceClient() + # maintenance_client.test_create_maintenance() + # maintenance_client.test_get_all_maintenance() + # maintenance_client.test_get_maintenance_by_id() + # maintenance_client.test_update_maintenance_by_id() + # maintenance_client.test_delete_maintenance() + + # postmortem_client = TestSDKPostMortemClient() + # postmortem_client.test_create_postmortem() + # postmortem_client.test_get_postmortem_by_id() + # postmortem_client.test_update_postmortem() + # postmortem_client.test_delete_postmortem() + + # priority_client = TestSDKPrioritiesClient() + # priority_client.test_create_priority() + # priority_client.test_get_all_priorities() + # priority_client.test_get_priority_by_id() + # priority_client.test_update_priority() + # priority_client.test_delete_priority() + + # roles_client = TestSDKRolesClient() + # roles_client.test_create_role() + # roles_client.test_get_incident_role_by_id() + # roles_client.test_update_incident_role() + # roles_client.test_delete_incident_role() + + # schedules_client = TestSDKSchedulesClient() + # schedules_client.test_create_schedule() + # schedules_client.test_get_all_schedules() + # schedules_client.test_get_schedule_by_id() + # schedules_client.test_update_schedule() + # schedules_client.test_delete_schedule() + + services_client = TestSDKServicesClient() + services_client.test_create_service() + + pass From 2c0101bed9aa84f3d82319e9486ff469008fe82d Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 17 Sep 2024 14:39:32 +0530 Subject: [PATCH 06/22] Update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index bb9e6a0..2f4cda4 100644 --- a/README.md +++ b/README.md @@ -113,7 +113,7 @@ class SDKAccountMembersClient(SDKTeamsClient): #### PATCH - Update Account Member ```python update_account_member = self.account_member_client.update_account_member( - account_member_username=, + account_member_username=, first_name=test_first_name, last_name=f"Doe {random.randint(2,10000000000000000000000)}", role=2, @@ -123,7 +123,7 @@ update_account_member = self.account_member_client.update_account_member( #### Get details about a particular team member ````python account_member = self.account_member_client.get_account_member( - account_member_id= + account_member_id= ) ```` #### GET - Get all the members of a team @@ -134,7 +134,7 @@ account_members = self.account_member_client.get_all_members() #### DEL - Delete an Account member #### Delete a particular member of the team. ````python -delete_account_member = self.account_member_client.delete_account_member(account_member_id=) +delete_account_member = self.account_member_client.delete_account_member(account_member_id=) ```` From bfa77ab5decf85d5144c8a77c6f319e7fe861848 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Thu, 16 Jan 2025 18:41:49 +0530 Subject: [PATCH 07/22] added init for oncall module, added updated tests and an updated setup.py --- .gitignore | 3 +- setup.py | 22 +- tests/test_sdk_automated.py | 334 +++++++++++++------------ zenduty/apiV2/teams/oncall/__init__.py | 0 4 files changed, 190 insertions(+), 169 deletions(-) create mode 100644 zenduty/apiV2/teams/oncall/__init__.py diff --git a/.gitignore b/.gitignore index 1c97479..5e6da28 100644 --- a/.gitignore +++ b/.gitignore @@ -22,4 +22,5 @@ zenduty/.DS_Store __pycache__/ *.pyc venv/ -.idea/ +assets/ +/.pytest_cache/ diff --git a/setup.py b/setup.py index ceab627..474ae3b 100644 --- a/setup.py +++ b/setup.py @@ -2,12 +2,12 @@ setup( name="zenduty-api", - version="0.8", + version="2.6", description="Python SDK wrapper for the Zenduty API", long_description="Python SDK wrapper for the Zenduty API", long_description_content_type="text/x-rst", - author="Vishwa Krishnakumar", - author_email="vishwa@yellowant.com", + author="Javeed Yara", + author_email="javeed@zenduty.com", packages=find_packages(), install_requires=[ "requests==2.32.3", @@ -15,7 +15,17 @@ "six==1.9.0", "charset-normalizer==3.3.2", "idna==3.7", - "certifi==2024.7.4" + "certifi==2024.7.4", ], - scripts=["bin/client.py"], -) \ No newline at end of file + url="https://github.com/Zenduty/zenduty-python-sdk", + license="MIT", + classifiers=[ + "Development Status :: 4 - Beta", # Update based on your package's status + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", # Specify Python versions supported + ], + python_requires=">=3.6", # Specify the minimum Python version + scripts=["bin/client.py"], # Include any scripts you want to make executable +) diff --git a/tests/test_sdk_automated.py b/tests/test_sdk_automated.py index fd0581c..ad0cdd0 100644 --- a/tests/test_sdk_automated.py +++ b/tests/test_sdk_automated.py @@ -26,12 +26,13 @@ class SDKTestingClient: - def __init__(self): - self.cred = ZendutyCredential("e3464dbec1590e0c226685e156f40ed541c3b715") - self.client = ZendutyClient( - credential=self.cred, use_https=True + @classmethod + def setup_class(cls): + cls.cred = ZendutyCredential("e3464dbec1590e0c226685e156f40ed541c3b715") + cls.client = ZendutyClient( + credential=cls.cred, use_https=True ) # defaults to default service endpoint zenduty.com - self.datetime_timestamp = self.datetime_timestamp() + cls.datetime_timestamp = cls.datetime_timestamp() @staticmethod def datetime_timestamp(): @@ -45,15 +46,16 @@ def generate_uuid() -> str: @pytest.mark.teams class TestSDKTeamsClient(SDKTestingClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.team_members = [] - self.team_member_unique_id = [] - self.teams_client = TeamsClient(client=self.client) - self.team_member_id = "773c69f5-78f2-42ca-b3d9-b" - self.invite_url = "https://zenduty.com/api/invite/accept/" - self.test_team_name = f"Team - {self.datetime_timestamp}" + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.team_members = [] + cls.team_member_unique_id = [] + cls.teams_client = TeamsClient(client=cls.client) + cls.team_member_id = "773c69f5-78f2-42ca-b3d9-b" + cls.invite_url = "https://zenduty.com/api/invite/accept/" + cls.test_team_name = f"Team - {cls.datetime_timestamp}" @staticmethod def create_team(self): @@ -68,6 +70,7 @@ def delete_team(self): def test_create_team(self): # Team1 is the name of the team and that is the payload create_team = self.teams_client.create_team(self.test_team_name) + print("Here") self.team_ids.append(create_team) assert create_team.name == self.test_team_name time.sleep(2) @@ -134,12 +137,13 @@ def test_delete_teams(self): @pytest.mark.accountmembers class TestSDKAccountMembersClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.account_member_ids = [] - self.teams_client = TeamsClient(client=self.client) - self.account_member_client = AccountMemberClient(client=self.client) + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.account_member_ids = [] + cls.teams_client = TeamsClient(client=cls.client) + cls.account_member_client = AccountMemberClient(client=cls.client) def test_account_members_invite(self): create_team = self.teams_client.create_team( @@ -188,10 +192,11 @@ def test_delete_account_member(self): @pytest.mark.accountroles class TestSDKAccountRolesClient(SDKTestingClient): - def __init__(self): - super().__init__() - self.account_role_ids = [] - self.account_role_client = AccountRoleClient(client=self.client) + @classmethod + def setup_class(cls): + super().setup_class() + cls.account_role_ids = [] + cls.account_role_client = AccountRoleClient(client=cls.client) def test_create_account_role(self): test_name = f"Account Role - {self.datetime_timestamp}" @@ -239,11 +244,12 @@ def test_delete_account_role(self): @pytest.mark.GER class TestSDKGERClients(SDKTestingClient): - def __init__(self): - super().__init__() - self.router_ids = [] - self.router_client = RouterClient(client=self.client) - self.router_name = f"Router - {self.datetime_timestamp}" + @classmethod + def setup_class(cls): + super().setup_class() + cls.router_ids = [] + cls.router_client = RouterClient(client=cls.client) + cls.router_name = f"Router - {cls.datetime_timestamp}" def test_create_router(self): create_router = self.router_client.create_router( @@ -284,11 +290,12 @@ def test_delete_router(self): @pytest.mark.events class TestSDKEventsClient(SDKTestingClient): - def __init__(self): - super().__init__() - self.event_ids = [] - self.event_client = EventClient(client=self.client) - self.event_name = f"Event - {self.datetime_timestamp}" + @classmethod + def setup_class(cls): + super().setup_class() + cls.event_ids = [] + cls.event_client = EventClient(client=cls.client) + cls.event_name = f"Event - {cls.datetime_timestamp}" def test_get_router_client(self): get_router = self.event_client.get_router_client() @@ -322,22 +329,23 @@ def test_create_event(self): @pytest.mark.escalationpolicy class TestSDKEscalationPolicyClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.escalation_policy_ids = [] - self.account_member_ids = [] - self.team_ids = [] - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.account_member_client = AccountMemberClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.escalation_policy_ids = [] + cls.account_member_ids = [] + cls.team_ids = [] + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.account_member_client = AccountMemberClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.escalation_policy_client = self.teams_client.get_escalation_policy_client( - self.team_by_id + cls.escalation_policy_client = cls.teams_client.get_escalation_policy_client( + cls.team_by_id ) - self.ep_name = f"EP - {self.datetime_timestamp}" + cls.ep_name = f"EP - {cls.datetime_timestamp}" @staticmethod def generate_uuid() -> str: @@ -391,21 +399,20 @@ def test_delete_esp(self): @pytest.mark.maintenance class TestSDKMaintenanceClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.maintenance_ids = [] - self.account_member_ids = [] - self.team_ids = [] - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.maintenance_ids = [] + cls.account_member_ids = [] + cls.team_ids = [] + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.maintenance_client = self.teams_client.get_maintenance_client( - self.team_by_id - ) - self.maintenance_name = f"Maintenance Mode - {self.datetime_timestamp}" + cls.maintenance_client = cls.teams_client.get_maintenance_client(cls.team_by_id) + cls.maintenance_name = f"Maintenance Mode - {cls.datetime_timestamp}" def test_create_maintenance(self): create_maintenance = self.maintenance_client.create_team_maintenance( @@ -452,16 +459,17 @@ def test_delete_maintenance(self): @pytest.mark.incidents class TestSDKIncidentsClient(SDKTestingClient): - def __init__(self): - super().__init__() - self.incident_ids = [] - self.incident_number = [] - self.incident_notes_list = [] - self.incident_tags_list = [] - self.incident_client = IncidentClient(client=self.client) - self.incident_name = f"Incident - {self.datetime_timestamp}" - self.incident_notes = f"Incident Notes - {self.datetime_timestamp}" - self.incident_tags = f"Incident Tags - {self.datetime_timestamp}" + @classmethod + def setup_class(cls): + super().setup_class() + cls.incident_ids = [] + cls.incident_number = [] + cls.incident_notes_list = [] + cls.incident_tags_list = [] + cls.incident_client = IncidentClient(client=cls.client) + cls.incident_name = f"Incident - {cls.datetime_timestamp}" + cls.incident_notes = f"Incident Notes - {cls.datetime_timestamp}" + cls.incident_tags = f"Incident Tags - {cls.datetime_timestamp}" def test_create_incident(self): create_incident = self.incident_client.create_incident( @@ -566,25 +574,24 @@ def test_update_incident(self): @pytest.mark.postmortem class TestSDKPostMortemClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.incident_ids = [] - self.postmortem_ids = [] - self.account_member_ids = [] - self.incident_name = "blahblah" - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.incident_ids = [] + cls.postmortem_ids = [] + cls.account_member_ids = [] + cls.incident_name = "blahblah" + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.incident_client = IncidentClient(client=self.client) - self.incident_name = f"Incident - {self.datetime_timestamp}" - self.postmortem_client = self.teams_client.get_postmortem_client( - self.team_by_id - ) - self.postmortem_name = f"Postmortem - {self.datetime_timestamp}" + cls.incident_client = IncidentClient(client=cls.client) + cls.incident_name = f"Incident - {cls.datetime_timestamp}" + cls.postmortem_client = cls.teams_client.get_postmortem_client(cls.team_by_id) + cls.postmortem_name = f"Postmortem - {cls.datetime_timestamp}" def test_create_postmortem(self): # Create the Incident @@ -634,19 +641,20 @@ def test_delete_postmortem(self): @pytest.mark.priorities class TestSDKPrioritiesClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.priority_ids = [] - self.account_member_ids = [] - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.priority_ids = [] + cls.account_member_ids = [] + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.priority_client = self.teams_client.get_priority_client(self.team_by_id) - self.priority_name = f"Priority - {self.datetime_timestamp}" + cls.priority_client = cls.teams_client.get_priority_client(cls.team_by_id) + cls.priority_name = f"Priority - {cls.datetime_timestamp}" def test_create_priority(self): create_priority = self.priority_client.create_priority( @@ -687,19 +695,20 @@ def test_delete_priority(self): @pytest.mark.roles class TestSDKRolesClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.role_ids = [] - self.account_member_ids = [] - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.role_ids = [] + cls.account_member_ids = [] + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.role_client = self.teams_client.get_incident_role_client(self.team_by_id) - self.role_name = f"Role - {self.datetime_timestamp}" + cls.role_client = cls.teams_client.get_incident_role_client(cls.team_by_id) + cls.role_name = f"Role - {cls.datetime_timestamp}" def test_create_role(self): self.create_role = self.role_client.create_incident_role( @@ -736,20 +745,21 @@ def test_delete_incident_role(self): @pytest.mark.schedules class TestSDKSchedulesClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.schedules_ids = [] - self.account_member_ids = [] - self.uuid = self.generate_uuid() - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.schedules_ids = [] + cls.account_member_ids = [] + cls.uuid = cls.generate_uuid() + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.schedules_client = self.teams_client.get_schedule_client(self.team_by_id) - self.schedules_name = f"Schedules - {self.datetime_timestamp}" - self.layers = [ + cls.schedules_client = cls.teams_client.get_schedule_client(cls.team_by_id) + cls.schedules_name = f"Schedules - {cls.datetime_timestamp}" + cls.layers = [ { "name": "Layer 1", "is_active": True, @@ -767,7 +777,7 @@ def __init__(self): } ] - self.overrides = [ + cls.overrides = [ { "name": "", "user": "3544118d-fbf5-41e5-ae6c-5", @@ -815,31 +825,32 @@ def test_delete_schedule(self): @pytest.mark.services class TestSDKServicesClient(TestSDKTeamsClient): - def __init__(self): - super().__init__() - self.team_ids = [] - self.sla_ids = [] - self.priority_ids = [] - self.escalation_policy_ids = [] - self.service_ids = [] + @classmethod + def setup_class(cls): + super().setup_class() + cls.team_ids = [] + cls.sla_ids = [] + cls.priority_ids = [] + cls.escalation_policy_ids = [] + cls.service_ids = [] # Making the Teams Client - self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) + cls.teams_client = TeamsClient(client=cls.client) + cls.team_ids.append(cls.create_team(cls)) # Making the Service Client - self.service_client = self.teams_client.get_service_client(self.team_ids[0]) - self.team_by_id = self.teams_client.find_team_by_id( + cls.service_client = cls.teams_client.get_service_client(cls.team_ids[0]) + cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) - self.escalation_policy_client = self.teams_client.get_escalation_policy_client( - self.team_by_id + cls.escalation_policy_client = cls.teams_client.get_escalation_policy_client( + cls.team_by_id ) - self.priority_client = self.teams_client.get_priority_client(self.team_by_id) - self.sla_client = self.teams_client.get_sla_client(self.team_by_id) + cls.priority_client = cls.teams_client.get_priority_client(cls.team_by_id) + cls.sla_client = cls.teams_client.get_sla_client(cls.team_by_id) # Making the names - self.ep_name = f"EP - {self.datetime_timestamp}" - self.priority_name = f"Priority - {self.datetime_timestamp}" - self.sla_name = f"SLA - {self.datetime_timestamp}" - self.service_name = f"Service - {self.datetime_timestamp}" + cls.ep_name = f"EP - {cls.datetime_timestamp}" + cls.priority_name = f"Priority - {cls.datetime_timestamp}" + cls.sla_name = f"SLA - {cls.datetime_timestamp}" + cls.service_name = f"Service - {cls.datetime_timestamp}" def test_create_service(self): # Create the escalation policy @@ -890,11 +901,12 @@ def test_create_service(self): @pytest.mark.integrations class TestSDKIntegrationClient(TestSDKServicesClient): - def __init__(self): - super().__init__() - self.service_ids = [] - integration_client = self.service_client.get_integration_client( - svc=self.service_ids[0] + @classmethod + def setup_class(cls): + super().setup_class() + cls.service_ids = [] + integration_client = cls.service_client.get_integration_client( + svc=cls.service_ids[0] ) @@ -917,18 +929,18 @@ class TestSDKTaskTemplatesClient(SDKTestingClient): # escalations_client = TestSDKEscalationPolicyClient() # escalations_client.test_create_escalation_policy() - # teams_client = TestSDKTeamsClient() - # teams_client.test_create_team() - # teams_client.test_find_team_by_id() - # teams_client.test_list_team_member() - # teams_client.test_add_team_member() - # teams_client.test_find_team_member() - # teams_client.test_update_team_member() - # teams_client.test_delete_team_member() - # teams_client.test_fetch_team_permissions() - # teams_client.update_team_permissions() - # teams_client.test_update_teams() - # teams_client.test_delete_teams() + teams_client = TestSDKTeamsClient() + teams_client.test_create_team() + teams_client.test_find_team_by_id() + teams_client.test_list_team_member() + teams_client.test_add_team_member() + teams_client.test_find_team_member() + teams_client.test_update_team_member() + teams_client.test_delete_team_member() + teams_client.test_fetch_team_permissions() + teams_client.update_team_permissions() + teams_client.test_update_teams() + teams_client.test_delete_teams() # router_client = TestSDKGERClients() # router_client.test_create_router() @@ -1015,7 +1027,5 @@ class TestSDKTaskTemplatesClient(SDKTestingClient): # schedules_client.test_update_schedule() # schedules_client.test_delete_schedule() - services_client = TestSDKServicesClient() - services_client.test_create_service() - - pass + # services_client = TestSDKServicesClient() + # services_client.test_create_service() diff --git a/zenduty/apiV2/teams/oncall/__init__.py b/zenduty/apiV2/teams/oncall/__init__.py new file mode 100644 index 0000000..e69de29 From 06885378e8b2de676113a353a4eecc3b08c6f5eb Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Fri, 17 Jan 2025 13:56:32 +0530 Subject: [PATCH 08/22] Updated setup.py, changed the version --- README.md | 507 +++++++++++++++++++++++++++++++++++------------------- setup.py | 3 +- 2 files changed, 334 insertions(+), 176 deletions(-) diff --git a/README.md b/README.md index 2f4cda4..f3077c5 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ # What is Zenduty?? + Zenduty is a cutting edge platform for incident management. With high level automation, Zenduty enables faster and better incident resolution keeping developers first. # Zenduty Python SDK @@ -8,31 +9,33 @@ Python SDK to communicate with zenduty endpoints ## Installing Installation can be done through pip, as follows: -```sh + +```sh $ pip install zenduty-api ``` -or you may grab the latest source code from GitHub: + +or you may grab the latest source code from GitHub: + ```sh $ git clone https://github.com/Zenduty/zenduty-python-sdk $ python3 setup.py install ``` ## Contents -1) zenduty/api : contains the functions to communicate with zenduty API endpoints -2) zenduty/ : contains the common required files -3) bin/ : contains sample script to run zenduty functions + +1. zenduty/api : contains the functions to communicate with zenduty API endpoints +2. zenduty/ : contains the common required files +3. bin/ : contains sample script to run zenduty functions ## Getting started Before you begin making use of the SDK, make sure you have your Zenduty Access Token. You can then import the package into your python script. -First of all, start off by making a client which connects to Zenduty using API Token. And create a team, most of the operations we'd do start off by creating a team, and creating services. For now, we will start off with creating an instance of a team. - +First of all, start off by making a client which connects to Zenduty using API Token. And create a team, most of the operations we'd do start off by creating a team, and creating services. For now, we will start off with creating an instance of a team. The Approach here is to make clients here, every module will get a new client to make things simpler and easier for us to understand. - ```python import zenduty @@ -46,52 +49,64 @@ class SDKTestingClient: It is important to note that each function returns a urllib3.response.HTTPResponse object. - ## Teams -This object represents a team of the account. It lets you create different independent operational units in the account. You can check out the team docs here https://docs.zenduty.com/docs/teams. -A Team can have multiple Members, Services, Integrations, Schedules, Escalation Policies, Priorities, Maintenance, etc.. +This object represents a team of the account. It lets you create different independent operational units in the account. You can check out the team docs here https://docs.zenduty.com/docs/teams. +A Team can have multiple Members, Services, Integrations, Schedules, Escalation Policies, Priorities, Maintenance, etc.. #### POST - Create a new team -````python + +```python class SDKTeamsClient(SDKTestingClient): def __init__(self): super().__init__() self.teams_client = TeamsClient(client=self.client) - self.team_member_id = # Random member id. + self.team_member_id = # Random member id. self.invite_url = "https://zenduty.com/api/invite/accept/" self.test_team_name = f"Team - {self.datetime_timestamp}" def create_team(self): create_team = self.teams_client.create_team(self.test_team_name) return create_team -```` +``` + +From here on, use this team object returned by create_team() to get the unique id of that team by calling it like this. + #### GET - List Teams + #### Will fetch all the teams present in that account -````python + +```python list_teams = self.teams_client.list_teams() -```` +``` + #### PATCH - Update teams -#### Update the team -````python + +#### Update the team + +```python update_teams = self.teams_client.update_team( - , name="Updated Team Name" + , name="Updated Team Name" ) -```` +``` + #### DEL - Delete team -````python -delete_teams = self.teams_client.delete_team() -```` +```python +delete_teams = self.teams_client.delete_team() +``` + +## Account Member -## Account Member This object represents an account user. Each account member object has a role, which can be "owner," "admin," or "user." An account can have only one owner, but multiple admins and users. Prerequisite: A team must be created, where the role of each member can be assigned. #### GET - Invite a member to the team + #### Invite a member to the team. + ```python class SDKAccountMembersClient(SDKTeamsClient): def __init__(self): @@ -101,7 +116,7 @@ class SDKAccountMembersClient(SDKTeamsClient): def account_members_invite(self): test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" - + account_member_invite = self.account_member_client.invite( team_id = , # UUID, which is unique_id of the team first_name="John", @@ -110,40 +125,51 @@ class SDKAccountMembersClient(SDKTeamsClient): email=test_email, ) ``` + #### PATCH - Update Account Member + ```python update_account_member = self.account_member_client.update_account_member( - account_member_username=, + account_member_username=, first_name=test_first_name, last_name=f"Doe {random.randint(2,10000000000000000000000)}", role=2, ) ``` + #### GET - Get Account member + #### Get details about a particular team member -````python + +```python account_member = self.account_member_client.get_account_member( account_member_id= ) -```` +``` + #### GET - Get all the members of a team + #### Get details of all the members of the team. -````python + +```python account_members = self.account_member_client.get_all_members() -```` +``` + #### DEL - Delete an Account member + #### Delete a particular member of the team. -````python -delete_account_member = self.account_member_client.delete_account_member(account_member_id=) -```` +```python +delete_account_member = self.account_member_client.delete_account_member(account_member_id=) +``` ## Account Roles #### POST - Create Account Role + #### There are a list of permissions you could give to a role. Please refer to these docs, https://apidocs.zenduty.com/#tag/Account-Custom-Role. -````python +```python class SDKAccountRolesClient(SDKTestingClient): def __init__(self): super().__init__() @@ -156,19 +182,25 @@ class SDKAccountRolesClient(SDKTestingClient): description="Account Role Description", permissions=["sla_read"], ) -```` -#### GET - Get an Account Role -````python +``` + +#### GET - Get an Account Role + +```python get_account_role = self.account_role_client.get_account_role( account_role_id= ) -```` +``` + #### GET - Get a list of roles -````python + +```python list_account_roles = self.account_role_client.list_account_roles() -```` +``` + #### PATCH - Update an Account Role -````python + +```python test_name = f"Updated Account Role - {self.datetime_timestamp}" update_account_role = self.account_role_client.update_account_role( account_role_id=, @@ -176,13 +208,15 @@ test_name = f"Updated Account Role - {self.datetime_timestamp}" description="Updated Account Role Description", permissions=["sla_read"], ) -```` +``` + #### DEL - Delete an Account Role -````python + +```python delete_account_role = self.account_role_client.delete_account_role( account_role_id= ) -```` +``` ## Global Event Router @@ -191,7 +225,8 @@ Global Event Router is a webhook, when sent requests to it, would navigate it to Refer to this, for more information, https://apidocs.zenduty.com/#tag/Global-Router. #### POST - Create Router -````python + +```python class SDKGERClients(SDKTestingClient): def __init__(self): super().__init__() @@ -203,33 +238,43 @@ class SDKGERClients(SDKTestingClient): name=self.router_name, description="Router Description", ) -```` +``` + #### GET - List Routers -````python + +```python list_router = self.router_client.get_all_routers() -```` +``` + #### GET - Get Router by ID -````python + +```python find_router = self.router_client.get_router_by_id(router_id=) -```` +``` + #### PATCH - Update a particular Router -````python + +```python update_router = self.router_client.update_router( , name="Updated Router Name", description="Updated Router Description", ) -```` +``` + #### DEL - Delete a particular Router -````python + +```python delete_router = self.router_client.delete_router() -```` +``` ## Events + This object represents the events of an integration. #### POST - Create an Event -````python + +```python class SDKEventsClient(SDKTestingClient): def __init__(self): super().__init__() @@ -259,13 +304,15 @@ class SDKEventsClient(SDKTestingClient): ], ) -```` +``` ## Escalation Policy + Escalation policies dictate how an incident created within a service escalates within your team. #### POST - Create an Escalation Policy -````python + +```python class SDKEscalationPolicyClient(SDKTeamsClient): # Inheriting a few methods from the Teams Object. def __init__(self): @@ -297,33 +344,43 @@ class SDKEscalationPolicyClient(SDKTeamsClient): self.ep_name, rules=self.rule_build ) -```` +``` + #### GET - Get Escalation Policies by ID -````python + +```python self.escalation_policy_client.get_esp_by_id( esp_id= ) -```` +``` + #### POST - Update Escalation Policy -````python + +```python update_esp = self.escalation_policy_client.update_esp( esp=, name="Test Updated", rules=self.rule_build, ) -```` +``` + #### GET - Get all the escalation policies -````python + +```python all_esp = self.escalation_policy_client.get_all_policies() -```` +``` + #### DEL - Delete an Escalation Policy -````python + +```python delete_esp = self.escalation_policy_client.delete_esp(esp=) -```` +``` ## Schedules + #### POST - Create an Escalation Policy -````python + +```python class SDKSchedulesClient(SDKTeamsClient): def __init__(self): super().__init__() @@ -370,35 +427,44 @@ class SDKSchedulesClient(SDKTeamsClient): overrides=self.overrides, ) -```` +``` + #### GET - Get all Schedules -````python + +```python get_all_schedules = self.schedules_client.get_all_schedules() -```` +``` + #### GET - Get Schedules by ID -````python + +```python self.get_schedule_by_id = self.schedules_client.get_schedule_by_id( schedule_id= ) -```` +``` + #### POST - Update a Schedule -````python + +```python update_schedule = self.schedules_client.update_schedule( schedule=, name="Test Schedule Updated", ) -```` +``` + #### DEL - Delete a Schedule -````python + +```python delete_schedule = self.schedules_client.delete_schedule( schedule= ) -```` +``` ## Maintenance #### POST - Create a Maintenance -````python + +```python class SDKMaintenanceClient(SDKTeamsClient): def __init__(self): super().__init__() @@ -420,15 +486,19 @@ class SDKMaintenanceClient(SDKTeamsClient): end_time="2026-07-08T18:06:00", service_ids=[list], ) -```` +``` + #### GET - Get all Maintenances -````python + +```python get_maintenance_by_id = self.maintenance_client.get_maintenance_by_id( maintenance_id= ) -```` +``` + #### PATCH - Update a Maintenance -````python + +```python update_maintenance = self.maintenance_client.update_maintenance( maintenance_id=, name="Updated Maintenance Name", @@ -436,15 +506,18 @@ update_maintenance = self.maintenance_client.update_maintenance( end_time="2026-07-08T18:06:00", service_ids=[list], ) -```` +``` + #### DEL - Delete a Maintenance -````python + +```python delete_maintenance = self.maintenance_client.delete_maintenance( maintenance_id=unique_id of a maintenance> ) -```` +``` ## Incidents + What is an Incident?? An incident on Zenduty is an event that is not part of usual operations, and that disrupts operational processes within a Service that is owned by a team. Incidents can be automatically created by an alert integration within the service or manually by a user. @@ -456,7 +529,8 @@ Acknowledged: When an incident is acknowledged by a user, Zenduty stops all furt Resolved: Marking an incident as resolved implies that the incident has been remediated. Incidents can be resolved automatically by the service integration that created it, or manually by a user. #### POST - Create an Incident -````python + +```python class SDKIncidentsClient(SDKTestingClient): def __init__(self): super().__init__() @@ -470,9 +544,11 @@ class SDKIncidentsClient(SDKTestingClient): title=self.incident_name, service= ) -```` +``` + #### POST - Create an Incident Note -````python + +```python self.note_client = self.incident_client.get_note_client( incident_id= ) @@ -481,65 +557,85 @@ class SDKIncidentsClient(SDKTestingClient): create_incident_note = self.note_client.create_incident_note( note=self.incident_notes ) -```` +``` + #### GET - Get all Incident Notes -````python + +```python get_all_incident_notes = self.note_client.get_all_incident_notes() -```` +``` + #### GET - Get Incident note by id -````python + +```python get_incident_note_by_id = self.note_client.get_incident_note_by_id( incident_note_unique_id= ) -```` +``` + #### PATCH - Update an Incident note -````python + +```python update_incident_note = self.note_client.update_incident_note( incident_note_unique_id=, note="Updated Incident Note", ) -```` +``` + #### DEL - Delete an Incident note -````python + +```python delete_incident_note = self.note_client.delete_incident_note( incident_note_unique_id= ) -```` +``` + #### POST - Create an Incident Tag -````python + +```python self.tag_client = self.incident_client.get_tags_client() create_incident_tag = self.tag_client.create_tag( team_tag= ) -```` +``` + #### GET - Get all Incident Tags -````python + +```python get_all_tags = self.tag_client.get_all_tags() -```` +``` + #### GET - Get all Incidents -````python + +```python get_all_incidents = self.incident_client.get_all_incidents(page=1) -```` +``` + #### GET - Get Alerts of Incidents -````python + +```python get_alerts_by_incident = self.incident_client.get_alerts_for_incident( incident_number ) -```` +``` + #### PATCH - Update an Incident -````python + +```python update_incident = self.incident_client.update_incident( incident_id=, title="Updated Incident Name", status=3, service="a91a3a00-8de9-472c-ad2e-61e7c89db062", ) -```` +``` ## Postmortem + #### POST - Create a Postmortem -````python + +```python class SDKPostMortemClient(TestSDKTeamsClient): def __init__(self): super().__init__() @@ -570,32 +666,40 @@ class SDKPostMortemClient(TestSDKTeamsClient): title="Test Postmortem", ) -```` +``` + #### GET - Get postmortem by id -````python + +```python self.postmortem_by_id = self.postmortem_client.get_postmortem_by_id( postmortem_id= ) -```` +``` + #### PATCH - Update a postmortem -````python + +```python pdate_postmortem = self.postmortem_client.update_postmortem( , author=, incidents=[list], title="Test Postmortem Updated", ) -```` +``` + #### DEL - Delete a postmortem -````python + +```python delete_postmortem = self.postmortem_client.delete_postmortem( ) -```` +``` ## Priorities + #### POST - Create a priority -````python + +```python class SDKPrioritiesClient(SDKTeamsClient): def __init__(self): super().__init__() @@ -615,33 +719,43 @@ class SDKPrioritiesClient(SDKTeamsClient): color="red", ) -```` +``` + #### GET - Get all priorities -````python + +```python get_all_priorities = self.priority_client.get_all_priorities() -```` +``` + #### GET - Get priorities by ID -````python + +```python self.priority_by_id = self.priority_client.get_priority_by_id( priority_id= ) -```` +``` + #### PATCH - Update the priority -````python + +```python update_priority = self.priority_client.update_priority( , name="Test Priority Updated", description="Test Priority", ) -```` +``` + #### DEL - Delete a priority -````python + +```python delete_priority = self.priority_client.delete_priority() -```` +``` ## Roles + #### POST - Create a Role -````python + +```python class SDKRolesClient(SDKTeamsClient): def __init__(self): super().__init__() @@ -660,30 +774,38 @@ class SDKRolesClient(SDKTeamsClient): description="Test Role", rank=1, ) -```` +``` + #### GET - Get incident role by id -````python + +```python self.get_role_by_id = self.role_client.get_incident_role_by_id( role_id= ) -```` +``` + #### PATCH - Update an incident role -````python + +```python self.update_role = self.role_client.update_incident_role( role=, title="Test Role Updated", ) -```` +``` + #### DEL - Delete an incident role -````python + +```python self.delete_role = self.role_client.delete_incident_role( role= ) -```` +``` ## Services + #### POST - Create a Service -````python + +```python class SDKServicesClient(SDKTeamsClient): def __init__(self): super().__init__() @@ -739,106 +861,141 @@ class SDKServicesClient(SDKTeamsClient): team_priority=, sla=, ) -```` +``` ## Integrations + #### POST - Create an integration -````python + +```python integration_client = service_client.get_integration_client(svc=) create_integration = integration_client.create_intg( name="Test Integration", summary="Test Integration", application=) -```` +``` + #### GET - Get all integrations -````python + +```python all_integrations = integration_client.get_all_integrations() -```` +``` + #### GET - Get integration by id -````python + +```python integration_by_id = integration_client.get_intg_by_id(intg=) -```` +``` + #### PATCH - Update an integration -````python + +```python update_integration = integration_client.update_intg(intg=, name="Test Integration Updated", application=) -```` +``` + #### DEL - Delete an integration -````python + +```python delete_integration = integration_client.delete_intg(intg=) -```` +``` ## SLA + #### POST - Create an SLA -````python + +```python sla_client = team_client.get_sla_client(team_by_id) create_sla = sla_client.create_sla(name="Test SLA", escalations=[]) -```` +``` + #### GET - Get SLA by id -````python + +```python sla_by_id = sla_client.get_sla_by_id(sla_id=) -```` +``` + #### PATCH - Update SLA -````python + +```python update_sla = sla_client.update_sla(sla=, name="Test SLA Updated", escalations=[]) -```` +``` + #### DEL - Delete SLA -````python + +```python delete_sla sla_client.delete_sla(sla=) -```` +``` ## Tags + #### POST - Create a tag -````python + +```python tag_client = team_client.get_tag_client(team_by_id) create_tag = tag_client.create_tag(name="TestXsadasd", color="red") -```` +``` + #### GET - Get all tags -````python + +```python get_all_tags = tag_client.get_all_tags() -```` +``` + #### GET - GET tag by id -````python + +```python get_tag = tag_client.get_tag_by_id(tags_id = ) -```` +``` + #### PATCH - Update tag by id -````python + +```python update_tag = tag_client(tag = , name="updated name", color="green") -```` +``` + #### DEL - Delete tag -````python -delete_tag = tag_client(tag = ) -```` +```python +delete_tag = tag_client(tag = ) +``` ## Task templates + #### POST - Create a task template -````python + +```python task_template_client = team_client.get_task_template_client(team_by_id) create_task_template = task_template_client.create_task_template( name="Test Task Template", summary="Test Task Template" ) -```` +``` + #### GET - Get all task templates -````python + +```python get_all_task_templates = task_template_client.get_all_task_template() -```` +``` + #### GET - Get task templates by id -````python + +```python get_task_template_by_id = task_template_client.get_task_template_by_id( task_template_id= ) -```` +``` + #### PATCH - Update the task template -````python + +```python update_task_template = task_template_client.update_task_template( task_template = , name="Test Task Template Updated" ) -```` -#### DEL - Delete the task template -````python -delete_task_template = task_template_client.delete_task_template(task_template = ) -```` +``` +#### DEL - Delete the task template +```python +delete_task_template = task_template_client.delete_task_template(task_template = ) +``` # Running tests diff --git a/setup.py b/setup.py index 474ae3b..c13c139 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ setup( name="zenduty-api", - version="2.6", + version="1.0", description="Python SDK wrapper for the Zenduty API", long_description="Python SDK wrapper for the Zenduty API", long_description_content_type="text/x-rst", @@ -16,6 +16,7 @@ "charset-normalizer==3.3.2", "idna==3.7", "certifi==2024.7.4", + "regex==2024.11.6", ], url="https://github.com/Zenduty/zenduty-python-sdk", license="MIT", From 5a29408c722f7cd2e73cde838d5ec11da3bc1ac1 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Fri, 17 Jan 2025 14:07:16 +0530 Subject: [PATCH 09/22] Removed setup.py installation line from readme.md --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index f3077c5..acfc886 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,6 @@ or you may grab the latest source code from GitHub: ```sh $ git clone https://github.com/Zenduty/zenduty-python-sdk -$ python3 setup.py install ``` ## Contents From 88cff3f53b0dca862d2034087f309595fd59ed44 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Fri, 17 Jan 2025 16:07:36 +0530 Subject: [PATCH 10/22] added long description to reflect in pypi documentation --- setup.py | 47 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c13c139..8dba193 100644 --- a/setup.py +++ b/setup.py @@ -4,7 +4,52 @@ name="zenduty-api", version="1.0", description="Python SDK wrapper for the Zenduty API", - long_description="Python SDK wrapper for the Zenduty API", + long_description=""" + # Zenduty Python SDK + + The **Zenduty Python SDK** provides a seamless way to integrate with Zenduty's powerful incident management platform. Whether you're building automated workflows, custom dashboards, or advanced monitoring solutions, this SDK offers the tools you need to connect with Zenduty's API endpoints efficiently. + + ## About Zenduty + + Zenduty is a cutting-edge incident management platform designed to help teams resolve incidents faster, smarter, and with greater ease. By leveraging advanced automation, Zenduty ensures that developers and engineers stay in control during high-pressure scenarios. Zenduty empowers teams to: + + - Proactively identify and resolve issues before they escalate. + - Collaborate effectively to minimize downtime and service disruptions. + - Improve reliability and customer satisfaction with actionable insights. + + ## Why Use the Zenduty Python SDK? + + The Zenduty Python SDK is crafted for developers looking to integrate their applications or services with Zenduty. It simplifies the process of interacting with Zenduty's API and supports robust and scalable integrations for a variety of use cases, including: + + - Triggering, acknowledging, and resolving incidents programmatically. + - Accessing detailed analytics and reporting data. + - Managing services, teams, schedules, and escalation policies. + - Building automation pipelines for incident notifications and workflows. + + ## Key Features + + - **Ease of Use**: Intuitive methods and structures to reduce development time. + - **Comprehensive API Support**: Full access to Zenduty's endpoints for managing incidents, teams, schedules, and more. + - **Scalability**: Designed to handle complex workflows and high-volume environments. + - **Compatibility**: Works seamlessly with modern Python environments and frameworks. + + ## Installation + + You can install the Zenduty Python SDK quickly via pip: + + ```sh + $ pip install zenduty-api + ``` + + or you may grab the latest source code from GitHub: + + ```sh + $ git clone https://github.com/Zenduty/zenduty-python-sdk + ``` + + ## Docs + Please refer this link to understand the SDK better. https://github.com/Zenduty/zenduty-python-sdk + """, long_description_content_type="text/x-rst", author="Javeed Yara", author_email="javeed@zenduty.com", From 0c8fb4957af436689177e8ff6fcaeb7c9e2cb003 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 16:31:13 +0530 Subject: [PATCH 11/22] Create test-publish.yaml --- .github/workflows/test-publish.yaml | 53 +++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 .github/workflows/test-publish.yaml diff --git a/.github/workflows/test-publish.yaml b/.github/workflows/test-publish.yaml new file mode 100644 index 0000000..f0a5c0c --- /dev/null +++ b/.github/workflows/test-publish.yaml @@ -0,0 +1,53 @@ +name: Release and Publish + +on: + pull_request: + types: [closed] + branches: + - master + +jobs: + release-and-publish: + if: github.event.pull_request.merged == true + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Python 3.9 + uses: actions/setup-python@v4 + with: + python-version: "3.9" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build wheel setuptools twine + + - name: Build package + run: | + python setup.py sdist bdist_wheel + twine check dist/* + + - name: Get version + id: get_version + run: | + version=$(python setup.py --version) + echo "version=${version}" >> $GITHUB_OUTPUT + + - name: Create Release + uses: softprops/action-gh-release@v1 + with: + tag_name: v${{ steps.get_version.outputs.version }} + name: Release v${{ steps.get_version.outputs.version }} + body: | + Release for PR #${{ github.event.pull_request.number }} + ${{ github.event.pull_request.title }} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + - name: Publish to TestPyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }} + run: | + twine upload --repository testpypi dist/* From 3cfabd08cef02f535c710d42fbd537e98ce14a96 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 16:40:15 +0530 Subject: [PATCH 12/22] modified the setup.py --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 8dba193..c8b3847 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ setup( name="zenduty-api", - version="1.0", + version="1.0.0", description="Python SDK wrapper for the Zenduty API", long_description=""" # Zenduty Python SDK @@ -72,6 +72,6 @@ "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.9", # Specify Python versions supported ], - python_requires=">=3.6", # Specify the minimum Python version + python_requires=">=3.9", # Specify the minimum Python version scripts=["bin/client.py"], # Include any scripts you want to make executable ) From b845254567c500d07b8e8db88705e2d88dd19a3f Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 16:44:56 +0530 Subject: [PATCH 13/22] Create test-pr-chcker --- test-pr-chcker | 1 + 1 file changed, 1 insertion(+) create mode 100644 test-pr-chcker diff --git a/test-pr-chcker b/test-pr-chcker new file mode 100644 index 0000000..82a8a81 --- /dev/null +++ b/test-pr-chcker @@ -0,0 +1 @@ +Hiii, PR check From ba0b3904ccc4d7e13cb0d8578db14dfec56f4fc7 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 16:53:36 +0530 Subject: [PATCH 14/22] Pure test purposes --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c8b3847..b5e4226 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,7 @@ from setuptools import setup, find_packages setup( - name="zenduty-api", + name="zenduty-api-test", version="1.0.0", description="Python SDK wrapper for the Zenduty API", long_description=""" From 6cb248733f7b2020cb4b191342d381124b4bf6a7 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 16:58:33 +0530 Subject: [PATCH 15/22] Update test-publish.yaml --- .github/workflows/test-publish.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test-publish.yaml b/.github/workflows/test-publish.yaml index f0a5c0c..685e3ae 100644 --- a/.github/workflows/test-publish.yaml +++ b/.github/workflows/test-publish.yaml @@ -21,10 +21,12 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install build wheel setuptools twine + pip install --upgrade pip setuptools wheel twine build + pip install packaging==22 - name: Build package run: | + rm -rf dist/ build/ *.egg-info python setup.py sdist bdist_wheel twine check dist/* From d2ac243bafc8c0ed3a4a8718908288b78a3917ad Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:00:46 +0530 Subject: [PATCH 16/22] Update test-pr-chcker --- test-pr-chcker | 1 + 1 file changed, 1 insertion(+) diff --git a/test-pr-chcker b/test-pr-chcker index 82a8a81..cbfdbde 100644 --- a/test-pr-chcker +++ b/test-pr-chcker @@ -1 +1,2 @@ Hiii, PR check +PR Checker 2 From eabf245f68b30af651304d3c61644490cd8c2c05 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:02:22 +0530 Subject: [PATCH 17/22] Update test-publish.yaml --- .github/workflows/test-publish.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test-publish.yaml b/.github/workflows/test-publish.yaml index 685e3ae..3acb26f 100644 --- a/.github/workflows/test-publish.yaml +++ b/.github/workflows/test-publish.yaml @@ -52,4 +52,4 @@ jobs: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }} run: | - twine upload --repository testpypi dist/* + twine upload --repository testpypi dist/* --verbose From 728fb5dd382c69a75c5ac7ca06bbf185277f00fa Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:03:42 +0530 Subject: [PATCH 18/22] Update test-pr-chcker --- test-pr-chcker | 1 + 1 file changed, 1 insertion(+) diff --git a/test-pr-chcker b/test-pr-chcker index cbfdbde..b700867 100644 --- a/test-pr-chcker +++ b/test-pr-chcker @@ -1,2 +1,3 @@ Hiii, PR check PR Checker 2 +asdfasdfasdf From d6766b92071da26084a97c261528710bbaf5fd0f Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:09:53 +0530 Subject: [PATCH 19/22] Update setup.py --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index b5e4226..871a024 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ setup( name="zenduty-api-test", - version="1.0.0", + version="1.0.1", description="Python SDK wrapper for the Zenduty API", long_description=""" # Zenduty Python SDK From 52eb634ba1374a881660452afc1e7cc5a0a63df0 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:10:16 +0530 Subject: [PATCH 20/22] Update test-pr-chcker --- test-pr-chcker | 1 + 1 file changed, 1 insertion(+) diff --git a/test-pr-chcker b/test-pr-chcker index b700867..05bcf61 100644 --- a/test-pr-chcker +++ b/test-pr-chcker @@ -1,3 +1,4 @@ Hiii, PR check PR Checker 2 asdfasdfasdf +asdfasdfasdf From 1774b6609ab0bcd8aa1cff0113aa5edbcf02485b Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Tue, 21 Jan 2025 17:10:27 +0530 Subject: [PATCH 21/22] Update test-pr-chcker --- test-pr-chcker | 1 + 1 file changed, 1 insertion(+) diff --git a/test-pr-chcker b/test-pr-chcker index 05bcf61..16ecb83 100644 --- a/test-pr-chcker +++ b/test-pr-chcker @@ -2,3 +2,4 @@ Hiii, PR check PR Checker 2 asdfasdfasdf asdfasdfasdf +asdfasdfasdf - pr final check From f0471a2903ef93046c63bb34b90b6244e023cbf6 Mon Sep 17 00:00:00 2001 From: JaveedYara432 <167430797+JaveedYara432@users.noreply.github.com> Date: Wed, 22 Jan 2025 19:45:17 +0530 Subject: [PATCH 22/22] Added final readme.md, added maintenance templates --- README.md | 912 +++++++++++++--------- setup.py | 4 +- test-pr-chcker | 5 - tests/test_sdk_automated.py | 237 ++---- zenduty/apiV2/teams/maintenance/models.py | 3 + 5 files changed, 621 insertions(+), 540 deletions(-) delete mode 100644 test-pr-chcker diff --git a/README.md b/README.md index acfc886..ef28b8b 100644 --- a/README.md +++ b/README.md @@ -22,9 +22,10 @@ $ git clone https://github.com/Zenduty/zenduty-python-sdk ## Contents -1. zenduty/api : contains the functions to communicate with zenduty API endpoints -2. zenduty/ : contains the common required files -3. bin/ : contains sample script to run zenduty functions +1. zenduty/apiV2 : Contains proper Clients to communicate and execute each function +2. zenduty/api : contains the functions to communicate with zenduty API endpoints +3. zenduty/ : contains the common required files +4. bin/ : contains sample script to run zenduty functions ## Getting started @@ -35,15 +36,24 @@ First of all, start off by making a client which connects to Zenduty using API T The Approach here is to make clients here, every module will get a new client to make things simpler and easier for us to understand. +You will also notice most of the create functions will be creating an object, this is because we will need to pass them to update, and delete functions later on. you are free to use the sdk as you like. + ```python -import zenduty + +from zenduty.apiV2.authentication.zenduty_credential import ZendutyCredential +from zenduty.apiV2.client import ZendutyClient class SDKTestingClient: def __init__(self): - self.cred = ZendutyCredential("") + self.cred = ZendutyCredential() self.client = ZendutyClient( credential=self.cred, use_https=True ) # defaults to default service endpoint zenduty.com + self.datetime_timestamp = self.datetime_timestamp() + + @staticmethod + def datetime_timestamp(): + return datetime.now().strftime("%Y-%m-%d %H:%M:%S") ``` It is important to note that each function returns a urllib3.response.HTTPResponse object. @@ -54,96 +64,108 @@ This object represents a team of the account. It lets you create different indep A Team can have multiple Members, Services, Integrations, Schedules, Escalation Policies, Priorities, Maintenance, etc.. -#### POST - Create a new team - ```python class SDKTeamsClient(SDKTestingClient): def __init__(self): super().__init__() self.teams_client = TeamsClient(client=self.client) - self.team_member_id = # Random member id. self.invite_url = "https://zenduty.com/api/invite/accept/" self.test_team_name = f"Team - {self.datetime_timestamp}" +``` + +#### POST - Create a new team - def create_team(self): - create_team = self.teams_client.create_team(self.test_team_name) - return create_team +```python +def create_team(self): + create_team = self.teams_client.create_team(self.test_team_name) + self.team_obj = create_team # class object made to use later down the road + return create_team ``` From here on, use this team object returned by create_team() to get the unique id of that team by calling it like this. #### GET - List Teams -#### Will fetch all the teams present in that account +Will fetch all the teams present in that account ```python -list_teams = self.teams_client.list_teams() +def list_teams(self): + list_teams = self.teams_client.list_teams() + return list_teams ``` #### PATCH - Update teams -#### Update the team +Update the team ```python -update_teams = self.teams_client.update_team( - , name="Updated Team Name" - ) +def update_team(self): + update_team = self.teams_client.update_team(self.team_obj, name="Updated team name here") + return update_team ``` #### DEL - Delete team +Delete the team + ```python -delete_teams = self.teams_client.delete_team() +def delete_team(self): + return self.teams_client.delete_team(self.team_obj) ``` ## Account Member This object represents an account user. Each account member object has a role, which can be "owner," "admin," or "user." An account can have only one owner, but multiple admins and users. -Prerequisite: A team must be created, where the role of each member can be assigned. - -#### GET - Invite a member to the team - -#### Invite a member to the team. +Prerequisite: A team must be created, where the role of each member can be assigned. For our example, we are creating a new team using the create_team() method mentioned above. ```python + class SDKAccountMembersClient(SDKTeamsClient): def __init__(self): super().__init__() self.teams_client = TeamsClient(client=self.client) self.account_member_client = AccountMemberClient(client=self.client) + self.team_obj = self.create_team() #Will be used for the purpose of inviting users to the team - def account_members_invite(self): - test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" +``` + +#### GET - Invite a member to the team + +#### Invite a member to the team. + +```python +def test_invite(self): + test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + self.team_invite_object = self.account_member_client.invite( + team_id=self.team_obj.unique_id, + email=test_email, + first_name="Test", + last_name="User", + role=2, + ) - account_member_invite = self.account_member_client.invite( - team_id = , # UUID, which is unique_id of the team - first_name="John", - last_name="doe", - role=3, - email=test_email, - ) ``` #### PATCH - Update Account Member ```python -update_account_member = self.account_member_client.update_account_member( - account_member_username=, - first_name=test_first_name, - last_name=f"Doe {random.randint(2,10000000000000000000000)}", - role=2, -) +def test_update_account_member(self): + result = self.account_member_client.update_account_member( + self.team_invite_object, + "Updated", + "Member Details", + 2, + ) ``` #### GET - Get Account member -#### Get details about a particular team member +#### Get details about a particular team member (NOTE: To get account member you have to pass its user id, not AccountMember Uniqueid) ```python -account_member = self.account_member_client.get_account_member( - account_member_id= - ) +def test_get_account_member_by_id(self): + result = self.account_member_client.get_account_member(self.team_invite_object.user.username) ``` #### GET - Get all the members of a team @@ -151,7 +173,8 @@ account_member = self.account_member_client.get_account_member( #### Get details of all the members of the team. ```python -account_members = self.account_member_client.get_all_members() +def test_get_all_members(self): + result = self.account_member_client.get_all_members() ``` #### DEL - Delete an Account member @@ -159,62 +182,64 @@ account_members = self.account_member_client.get_all_members() #### Delete a particular member of the team. ```python -delete_account_member = self.account_member_client.delete_account_member(account_member_id=) +def test_delete_account_member(self): + self.account_member_client.delete_account_member(self.team_invite_object) ``` ## Account Roles -#### POST - Create Account Role - -#### There are a list of permissions you could give to a role. Please refer to these docs, https://apidocs.zenduty.com/#tag/Account-Custom-Role. +There are a list of permissions you could give to a role. Please refer to these docs, https://apidocs.zenduty.com/#tag/Account-Custom-Role. ```python class SDKAccountRolesClient(SDKTestingClient): def __init__(self): super().__init__() self.account_role_client = AccountRoleClient(client=self.client) +``` - def create_account_role(self): - test_name = f"Account Role - {self.datetime_timestamp}" - create_account_role = self.account_role_client.create_account_role( - name=test_name, - description="Account Role Description", - permissions=["sla_read"], - ) +#### POST - Create Account Role + +```python +def create_account_role(self): + test_name = f"Account Role - {self.datetime_timestamp}" + create_account_role = self.account_role_client.create_account_role( + name=test_name, + description="Account Role Description", + permissions=["sla_read"], + ) ``` #### GET - Get an Account Role ```python -get_account_role = self.account_role_client.get_account_role( - account_role_id= - ) +def test_get_account_role(self): + get_account_role = self.account_role_client.get_account_role(self.role_obj.unique_id) + return get_account_role ``` #### GET - Get a list of roles ```python -list_account_roles = self.account_role_client.list_account_roles() +def test_list_account_roles(self): + list_account_roles = self.account_role_client.list_account_roles() + return list_account_roles ``` #### PATCH - Update an Account Role ```python -test_name = f"Updated Account Role - {self.datetime_timestamp}" - update_account_role = self.account_role_client.update_account_role( - account_role_id=, - name=test_name, - description="Updated Account Role Description", - permissions=["sla_read"], - ) + +def test_update_account_role(self): + update_account_role = self.account_role_client.update_account_role(account_role=self.role_obj, permissions=["sla_read"]) + return update_account_role + ``` #### DEL - Delete an Account Role ```python -delete_account_role = self.account_role_client.delete_account_role( - account_role_id= - ) +def test_delete_account_role(self): + delete_account_role = self.account_role_client.delete_account_role(account_role=self.role_obj) ``` ## Global Event Router @@ -223,95 +248,106 @@ Global Event Router is a webhook, when sent requests to it, would navigate it to Refer to this, for more information, https://apidocs.zenduty.com/#tag/Global-Router. -#### POST - Create Router - ```python class SDKGERClients(SDKTestingClient): def __init__(self): super().__init__() self.router_client = RouterClient(client=self.client) self.router_name = f"Router - {self.datetime_timestamp}" +``` - def create_router(self): - create_router = self.router_client.create_router( - name=self.router_name, - description="Router Description", - ) +#### POST - Create Router + +```python +def create_router(self): + create_router = self.router_client.create_router( + name=self.router_name, + description="Router Description", + ) ``` #### GET - List Routers ```python -list_router = self.router_client.get_all_routers() +def get_all_routers(self): + return self.router_client.get_all_routers() ``` #### GET - Get Router by ID ```python -find_router = self.router_client.get_router_by_id(router_id=) +def get_router_by_id(self): + return self.router_client.get_router_by_id(self.router_obj.unique_id) ``` #### PATCH - Update a particular Router ```python -update_router = self.router_client.update_router( - , - name="Updated Router Name", - description="Updated Router Description", -) +def update_router(self): + self.router_client.update_router( + router = self.router_obj, + name = f"Router - {self.datetime_timestamp}", + description = "New Router Description", + ) ``` #### DEL - Delete a particular Router ```python -delete_router = self.router_client.delete_router() +def delete_router(self): + return self.router_client.delete_router(self.router_obj) ``` ## Events This object represents the events of an integration. -#### POST - Create an Event - ```python class SDKEventsClient(SDKTestingClient): def __init__(self): super().__init__() self.event_client = EventClient(client=self.client) self.event_name = f"Event - {self.datetime_timestamp}" +``` - def get_router_client(self): - get_router = self.event_client.get_router_client() - - def test_create_event(self): - create_event = self.event_client.create_event( - integration_key=, - alert_type="info", - message="This is info alert", - summary="This is the incident summary111", - entity_id=123455, - payload={ - "status": "ACME Payments are failing", - "severity": "1", - "project": "kubeprod", - }, - urls=[ - { - "link_url": "https://www.example.com/alerts/12345/", - "link_text": "Alert URL", - } - ], - ) +#### GET - Get Router Client + +```python +def get_router_client(self): + get_router = self.event_client.get_router_client() + +``` +#### POST - Create an Event + +```python +def test_create_event(self): + create_event = self.event_client.create_event( + integration_key=, + alert_type="info", + message="This is info alert", + summary="This is the incident summary111", + entity_id=123455, + payload={ + "status": "ACME Payments are failing", + "severity": "1", + "project": "kubeprod", + }, + urls=[ + { + "link_url": "https://www.example.com/alerts/12345/", + "link_text": "Alert URL", + } + ], + ) ``` ## Escalation Policy Escalation policies dictate how an incident created within a service escalates within your team. -#### POST - Create an Escalation Policy - ```python + class SDKEscalationPolicyClient(SDKTeamsClient): # Inheriting a few methods from the Teams Object. def __init__(self): @@ -319,45 +355,65 @@ class SDKEscalationPolicyClient(SDKTeamsClient): self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) self.account_member_client = AccountMemberClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= - ) + + # Team object: Needed for escalation policy client + self.team_obj = self.teams_client.create_team(name=f"ESP Team - {self.datetime_timestamp}") + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( - self.team_by_id + self.team_obj ) - self.ep_name = f"EP - {self.datetime_timestamp}" - def create_escalation_policy(self): + self.ep_name = f"EP - {self.datetime_timestamp}" - self.rule_build = [ - { - "delay": 0, - "targets": [ - {"target_type": 2, "target_id": "3544118d-fbf5-41e5-ae6c-5"} - ], - "position": 1, - } - ] - create_escalation_policy = self.escalation_policy_client.create_esp( - self.ep_name, rules=self.rule_build + # User required to add to escalation policy + self.test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + self.team_member_obj = self.account_member_client.invite( + team_id=self.team_obj.unique_id, + email=self.test_email, + first_name="Test", + last_name="User", + role=2, ) + def generate_uuid(self): + return uuid4() +``` + +#### POST - Create an Escalation Policy + +```python +def create_escalation_policy(self): + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": self.team_member_obj.user.username} + ], + "position": 1, + } + ] + + self.create_escalation_policy_obj = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) + ``` #### GET - Get Escalation Policies by ID ```python -self.escalation_policy_client.get_esp_by_id( - esp_id= -) +def test_get_esp_by_id(self): + self.escalation_policy_client.get_esp_by_id( + esp_id=self.create_escalation_policy_obj.unique_id + ) ``` #### POST - Update Escalation Policy ```python -update_esp = self.escalation_policy_client.update_esp( - esp=, +def test_update_esp(self): + update_esp = self.escalation_policy_client.update_esp( + esp=self.create_escalation_policy_obj, name="Test Updated", rules=self.rule_build, ) @@ -366,30 +422,42 @@ update_esp = self.escalation_policy_client.update_esp( #### GET - Get all the escalation policies ```python -all_esp = self.escalation_policy_client.get_all_policies() +def test_get_all_policies(self): + all_esp = self.escalation_policy_client.get_all_policies() + return all_esp ``` #### DEL - Delete an Escalation Policy ```python -delete_esp = self.escalation_policy_client.delete_esp(esp=) +def test_delete_esp(self): + delete_esp = self.escalation_policy_client.delete_esp(esp=self.create_escalation_policy_obj) + ``` ## Schedules -#### POST - Create an Escalation Policy - ```python class SDKSchedulesClient(SDKTeamsClient): def __init__(self): super().__init__() self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= + self.account_member_client = AccountMemberClient(client=self.client) + + self.team_obj = self.teams_client.create_team(name=f"Schedule Team - {self.datetime_timestamp}") + + # adding test user to the team + self.test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + self.team_member_obj = self.account_member_client.invite( + team_id=self.team_obj.unique_id, + email=self.test_email, + first_name="Test", + last_name="User", + role=2, ) - self.schedules_client = self.teams_client.get_schedule_client(self.team_by_id) + + self.schedules_client = self.teams_client.get_schedule_client(self.team_obj) self.schedules_name = f"Schedules - {self.datetime_timestamp}" self.layers = [ { @@ -402,51 +470,52 @@ class SDKSchedulesClient(SDKTeamsClient): "shift_length": 86400, "users": [ { - "user": , + "user":self.team_member_obj.user.username, "position": 1, } ], } ] - self.overrides = [ - { - "name": "", - "user": , - "start_time": "2024-07-29T11:54:34.745000Z", - "end_time": "2024-07-29T18:29:59.999000Z", - } - ] + def generate_uuid(self): + return uuid4() +``` - def create_schedule(self): - create_schedule = self.schedules_client.create_schedule( - name=self.schedules_name, - timezone="Asia/Kolkata", - layers=self.layers, - overrides=self.overrides, - ) +#### POST - Create an Escalation Policy +```python +def create_schedule(self): + create_schedule = self.schedules_client.create_schedule( + name=self.schedules_name, + timezone="Asia/Kolkata", + layers=self.layers, + overrides=self.overrides, + ) ``` #### GET - Get all Schedules ```python -get_all_schedules = self.schedules_client.get_all_schedules() +def test_get_all_schedules(self): + get_all_schedules = self.schedules_client.get_all_schedules() ``` #### GET - Get Schedules by ID ```python -self.get_schedule_by_id = self.schedules_client.get_schedule_by_id( - schedule_id= +def test_get_schedule_by_id(self): + self.get_schedule_by_id = self.schedules_client.get_schedule_by_id( + schedule_id=self.schedule_obj.unique_id ) + return self.get_schedule_by_id ``` #### POST - Update a Schedule ```python -update_schedule = self.schedules_client.update_schedule( - schedule=, +def test_update_schedule(self): + update_schedule = self.schedules_client.update_schedule( + schedule=self.schedule_obj, name="Test Schedule Updated", ) ``` @@ -454,65 +523,75 @@ update_schedule = self.schedules_client.update_schedule( #### DEL - Delete a Schedule ```python -delete_schedule = self.schedules_client.delete_schedule( - schedule= - ) +def test_delete_schedules(self): + delete_schedule = self.schedules_client.delete_schedule( + schedule=self.schedule_obj + ) ``` ## Maintenance -#### POST - Create a Maintenance - ```python class SDKMaintenanceClient(SDKTeamsClient): def __init__(self): super().__init__() self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) + + self.team_by_id = self.teams_client.find_team_by_id( - team_id= + team_id=self.team_ids[0].unique_id ) self.maintenance_client = self.teams_client.get_maintenance_client( self.team_by_id ) self.maintenance_name = f"Maintenance Mode - {self.datetime_timestamp}" - def create_maintenance(self): - create_maintenance = self.maintenance_client.create_team_maintenance( - name=self.maintenance_name, - start_time="2026-07-08T18:06:00", - end_time="2026-07-08T18:06:00", - service_ids=[list], - ) + def generate_uuid(self): + return uuid4() +``` + +#### POST - Create a Maintenance + +```python +def test_create_maintenance(self): + self.maintenance_obj = self.maintenance_client.create_team_maintenance( + name=self.maintenance_name, + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=[], + ) ``` #### GET - Get all Maintenances ```python -get_maintenance_by_id = self.maintenance_client.get_maintenance_by_id( - maintenance_id= +def test_get_maintenance_by_id(self): + get_maintenance_by_id = self.maintenance_client.get_maintenance_by_id( + maintenance_id=self.maintenance_obj.unique_id ) ``` #### PATCH - Update a Maintenance ```python -update_maintenance = self.maintenance_client.update_maintenance( - maintenance_id=, - name="Updated Maintenance Name", - start_time="2026-07-08T18:06:00", - end_time="2026-07-08T18:06:00", - service_ids=[list], - ) +def test_update_maintenance(self): + update_maintenance = self.maintenance_client.update_maintenance( + maintenance_id=self.maintenance_obj, + name="Updated Maintenance Name", + start_time="2026-07-08T18:06:00", + end_time="2026-07-08T18:06:00", + service_ids=[], + ) ``` #### DEL - Delete a Maintenance ```python -delete_maintenance = self.maintenance_client.delete_maintenance( - maintenance_id=unique_id of a maintenance> - ) +def test_delete_maintenance(self): + delete_maintenance = self.maintenance_client.delete_maintenance( + maintenance_id=self.maintenance_obj + ) ``` ## Incidents @@ -527,8 +606,6 @@ Triggered: Triggered is the first state of the incident. Zenduty will continue e Acknowledged: When an incident is acknowledged by a user, Zenduty stops all further escalations. Resolved: Marking an incident as resolved implies that the incident has been remediated. Incidents can be resolved automatically by the service integration that created it, or manually by a user. -#### POST - Create an Incident - ```python class SDKIncidentsClient(SDKTestingClient): def __init__(self): @@ -538,22 +615,34 @@ class SDKIncidentsClient(SDKTestingClient): self.incident_notes = f"Incident Notes - {self.datetime_timestamp}" self.incident_tags = f"Incident Tags - {self.datetime_timestamp}" - def create_incident(self): - create_incident = self.incident_client.create_incident( - title=self.incident_name, service= - ) + self.service_client = SDKServicesClient() + + + def generate_uuid(self): + return uuid4() +``` +#### POST - Create an Incident + +```python +def create_incident(self): + create_incident = self.incident_client.create_incident( + title=self.incident_name, service= + ) ``` #### POST - Create an Incident Note +NOTE: Here we are creating a note client using incident object, meaning it is important to first execute create incident before running this function. + ```python +def test_create_note(self): + # to create a notes functions self.note_client = self.incident_client.get_note_client( - incident_id= + incident=self.incident_obj ) - # Creating an incident note, attaching it to an incident - create_incident_note = self.note_client.create_incident_note( + self.incident_note_obj = self.note_client.create_incident_note( note=self.incident_notes ) ``` @@ -561,305 +650,358 @@ class SDKIncidentsClient(SDKTestingClient): #### GET - Get all Incident Notes ```python -get_all_incident_notes = self.note_client.get_all_incident_notes() +def test_get_all_incident_notes(self): + get_all_incident_notes = self.note_client.get_all_incident_notes() ``` #### GET - Get Incident note by id ```python - get_incident_note_by_id = self.note_client.get_incident_note_by_id( - incident_note_unique_id= - ) +def test_get_incident_by_note_id(self): + get_incident_note_by_id = self.note_client.get_incident_note_by_id( + incident_note_unique_id=self.incident_note_obj.unique_id + ) ``` #### PATCH - Update an Incident note ```python -update_incident_note = self.note_client.update_incident_note( - incident_note_unique_id=, - note="Updated Incident Note", - ) +def test_update_incident_note(self): + update_incident_note = self.note_client.update_incident_note( + incident_note=self.incident_note_obj, + note="Updated Incident Note", + ) ``` #### DEL - Delete an Incident note ```python - delete_incident_note = self.note_client.delete_incident_note( - incident_note_unique_id= - ) +def test_delete_incident_note(self): + delete_incident_note = self.note_client.delete_incident_note( + incident_note=self.incident_note_obj + ) ``` #### POST - Create an Incident Tag -```python - self.tag_client = self.incident_client.get_tags_client() +NOTE: All the functions below require a tag client to be made, There we must run this function before executing any incident tags functions. - create_incident_tag = self.tag_client.create_tag( - team_tag= - ) +```python +def test_create_tag_client(self): + self.tag_client = self.incident_client.get_tags_client(self.incident_obj) ``` #### GET - Get all Incident Tags ```python -get_all_tags = self.tag_client.get_all_tags() +def test_get_all_tags(self): + get_all_tags = self.tag_client.get_all_tags() + return get_all_tags ``` #### GET - Get all Incidents ```python -get_all_incidents = self.incident_client.get_all_incidents(page=1) +def test_get_all_incidents(self): + get_all_incidents = self.incident_client.get_all_incidents(page=1) + return get_all_incidents ``` #### GET - Get Alerts of Incidents ```python -get_alerts_by_incident = self.incident_client.get_alerts_for_incident( - incident_number - ) +def test_get_alert_on_incidents(self): + get_alerts_by_incident = self.incident_client.get_alerts_for_incident( + incident_number=self.incident_obj.incident_number + ) ``` #### PATCH - Update an Incident ```python -update_incident = self.incident_client.update_incident( - incident_id=, - title="Updated Incident Name", - status=3, - service="a91a3a00-8de9-472c-ad2e-61e7c89db062", - ) +def test_update_incident(self): + update_incident = self.incident_client.update_incident( + incident_id=self.incident_obj.unique_id, + title="Updated Incident Name", + status=3, + service="a91a3a00-8de9-472c-ad2e-61e7c89db062", + ) ``` ## Postmortem -#### POST - Create a Postmortem - ```python -class SDKPostMortemClient(TestSDKTeamsClient): +class SDKPostMortemClient(SDKTeamsClient): def __init__(self): super().__init__() - self.incident_name = "blahblah" self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= - ) + self.team_obj = self.teams_client.create_team(name=f"Post Mortem Team - {self.datetime_timestamp}") + + self.incident_client = IncidentClient(client=self.client) self.incident_name = f"Incident - {self.datetime_timestamp}" + self.postmortem_client = self.teams_client.get_postmortem_client( - self.team_by_id + self.team_obj ) + self.postmortem_name = f"Postmortem - {self.datetime_timestamp}" - def create_postmortem(self): - # Create the Incident - create_incident = self.incident_client.create_incident( - title=self.incident_name, service= - ) + def generate_uuid(self): + return uuid4() +``` - # Create the Postmortem - create_postmortem = self.postmortem_client.create_postmortem( - author=, - incidents=[list], - title="Test Postmortem", - ) +#### POST - Create a Postmortem + +```python +def test_create_postmortem(self): + # create new service + self.service_client = SDKServicesClient() + self.service_obj = self.service_client.test_create_service() + # Create the Incident + create_incident = self.incident_client.create_incident( + title=self.incident_name, service=self.service_obj.unique_id + ) + + # Create the Postmortem + self.postmortem_obj= self.postmortem_client.create_postmortem( + author="43b2493a-58e9-4454-9fe5-4", + incidents=[create_incident.unique_id], + title="Test Postmortem", + ) ``` #### GET - Get postmortem by id ```python -self.postmortem_by_id = self.postmortem_client.get_postmortem_by_id( - postmortem_id= - ) +def test_get_postmortem_by_id(self): + self.postmortem_by_id = self.postmortem_client.get_postmortem_by_id( + postmortem_id=self.postmortem_obj.unique_id + ) ``` #### PATCH - Update a postmortem ```python -pdate_postmortem = self.postmortem_client.update_postmortem( - , - author=, - incidents=[list], - title="Test Postmortem Updated", - ) +def test_update_postmortem(self): + update_postmortem = self.postmortem_client.update_postmortem( + self.postmortem_obj, + author="43b2493a-58e9-4454-9fe5-4", + incidents=[], + title="Test Postmortem Updated", + ) + ``` #### DEL - Delete a postmortem ```python -delete_postmortem = self.postmortem_client.delete_postmortem( - - ) +def test_delete_postmortem(self): + delete_postmortem = self.postmortem_client.delete_postmortem( + self.postmortem_obj + ) ``` ## Priorities -#### POST - Create a priority - ```python class SDKPrioritiesClient(SDKTeamsClient): def __init__(self): super().__init__() self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= - ) - self.priority_client = self.teams_client.get_priority_client(self.team_by_id) + + self.team_obj = self.teams_client.create_team(name=f"Post Mortem Team - {self.datetime_timestamp}") + + self.priority_client = self.teams_client.get_priority_client(self.team_obj) self.priority_name = f"Priority - {self.datetime_timestamp}" - def create_priority(self): - create_priority = self.priority_client.create_priority( - name=self.priority_name, - description="Priority Description", - color="red", - ) + def generate_uuid(self): + return uuid4() +``` + +#### POST - Create a priority +```python +def test_create_priority(self): + self.priority_obj = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) ``` #### GET - Get all priorities ```python -get_all_priorities = self.priority_client.get_all_priorities() +def test_get_all_priorities(self): + get_all_priorities = self.priority_client.get_all_priorities() + return get_all_priorities ``` #### GET - Get priorities by ID ```python -self.priority_by_id = self.priority_client.get_priority_by_id( - priority_id= - ) +def test_get_priority_by_id(self): + self.priority_by_id = self.priority_client.get_priority_by_id( + priority_id=self.priority_obj.unique_id + ) ``` #### PATCH - Update the priority ```python -update_priority = self.priority_client.update_priority( - , - name="Test Priority Updated", - description="Test Priority", - ) +def test_update_priority(self): + update_priority = self.priority_client.update_priority( + self.priority_obj, + name="Test Priority Updated", + description="Test Priority", + ) ``` #### DEL - Delete a priority ```python -delete_priority = self.priority_client.delete_priority() +def test_delete_priority(self): + delete_priority = self.priority_client.delete_priority(self.priority_obj) ``` ## Roles -#### POST - Create a Role - ```python class SDKRolesClient(SDKTeamsClient): def __init__(self): super().__init__() self.uuid = self.generate_uuid() self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= - ) - self.role_client = self.teams_client.get_incident_role_client(self.team_by_id) + self.team_obj = self.teams_client.create_team(name=f"Roles Team - {self.datetime_timestamp}") + + self.role_client = self.teams_client.get_incident_role_client(self.team_obj) self.role_name = f"Role - {self.datetime_timestamp}" - def create_role(self): - self.create_role = self.role_client.create_incident_role( - title="Test Role", - description="Test Role", - rank=1, - ) + def generate_uuid(self): + return uuid4() +``` + +#### POST - Create a Role + +```python +def test_create_role(self): + self.role_obj = self.role_client.create_incident_role( + title="Test Role", + description="Test Role", + rank=2, + ) ``` #### GET - Get incident role by id ```python - self.get_role_by_id = self.role_client.get_incident_role_by_id( - role_id= - ) +def test_get_role_by_id(self): + self.get_role_by_id = self.role_client.get_incident_role_by_id( + role_id=self.role_obj.unique_id + ) ``` #### PATCH - Update an incident role ```python -self.update_role = self.role_client.update_incident_role( - role=, - title="Test Role Updated", - ) +def test_update_role(self): + self.update_role = self.role_client.update_incident_role( + role=self.role_obj, + title="Test Role Updated", + ) ``` #### DEL - Delete an incident role ```python -self.delete_role = self.role_client.delete_incident_role( - role= - ) +def test_delete_role(self): + self.delete_role = self.role_client.delete_incident_role( + role=self.role_obj + ) ``` ## Services -#### POST - Create a Service - ```python class SDKServicesClient(SDKTeamsClient): def __init__(self): super().__init__() # Making the Teams Client self.teams_client = TeamsClient(client=self.client) - self.team_ids.append(self.create_team(self)) + self.team_obj = self.teams_client.create_team(name=f"Services Team - {self.datetime_timestamp}") + + # Making the Service Client - self.service_client = self.teams_client.get_service_client(self.team_ids[0]) - self.team_by_id = self.teams_client.find_team_by_id( - team_id= - ) + self.service_client = self.teams_client.get_service_client(self.team_obj) + self.escalation_policy_client = self.teams_client.get_escalation_policy_client( - self.team_by_id + self.team_obj ) - self.priority_client = self.teams_client.get_priority_client(self.team_by_id) - self.sla_client = self.teams_client.get_sla_client(self.team_by_id) + self.priority_client = self.teams_client.get_priority_client(self.team_obj) + self.sla_client = self.teams_client.get_sla_client(self.team_obj) + # Making the names self.ep_name = f"EP - {self.datetime_timestamp}" self.priority_name = f"Priority - {self.datetime_timestamp}" self.sla_name = f"SLA - {self.datetime_timestamp}" self.service_name = f"Service - {self.datetime_timestamp}" - def test_create_service(self): - # Create the escalation policy - self.rule_build = [ - { - "delay": 0, - "targets": [ - {"target_type": 2, "target_id": } - ], - "position": 1, - } - ] - create_escalation_policy = self.escalation_policy_client.create_esp( - self.ep_name, rules=self.rule_build + + self.account_member_client = AccountMemberClient(client=self.client) + self.test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" + self.team_member_obj = self.account_member_client.invite( + team_id=self.team_obj.unique_id, + email=self.test_email, + first_name="Test", + last_name="User", + role=2, ) +``` + +#### POST - Create a Service + +```python +def test_create_service(self): + # Create the escalation policy + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": self.team_member_obj.user.username} + ], + "position": 1, + } + ] + create_escalation_policy = self.escalation_policy_client.create_esp( + self.ep_name, rules=self.rule_build + ) - # Create the Priority - create_priority = self.priority_client.create_priority( - name=self.priority_name, - description="Priority Description", - color="red", - ) + # Create the Priority + create_priority = self.priority_client.create_priority( + name=self.priority_name, + description="Priority Description", + color="red", + ) - # Create the SLA - create_sla = self.sla_client.create_sla(name="Test SLA", escalations=[]) - # Finally create the service - create_service = self.service_client.create_service( - name=f"Test Service - {self.datetime_timestamp}", - escalation_policy=, - team_priority=, - sla=, - ) + + # Create the SLA + create_sla = self.sla_client.create_sla(name="Test SLA", escalations=[]) + + # Finally create the service + create_service = self.service_client.create_service( + name=f"Test Service - {self.datetime_timestamp}", + escalation_policy=create_escalation_policy.unique_id, + team_priority=create_priority.unique_id, + sla=create_sla.unique_id, + ) + + return create_service ``` ## Integrations @@ -899,101 +1041,147 @@ delete_integration = integration_client.delete_intg(intg=) +def test_get_sla_by_id(self): + sla_by_id = self.sla_client.get_sla_by_id(sla_id=self.sla_obj.unique_id) ``` #### PATCH - Update SLA ```python -update_sla = sla_client.update_sla(sla=, name="Test SLA Updated", escalations=[]) +def test_update_sla(self): + update_sla = self.sla_client.update_sla(sla=self.sla_obj, name="Test SLA Updated", escalations=[]) ``` #### DEL - Delete SLA ```python -delete_sla sla_client.delete_sla(sla=) +def test_delete_sla(self): + delete_sla = self.sla_client.delete_sla(sla=self.sla_obj) ``` ## Tags +```python +class SDKTagClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + self.team_obj = self.teams_client.create_team(name=f"Integration Team - {self.datetime_timestamp}") + + self.tag_client = self.teams_client.get_tag_client(self.team_obj) +``` + #### POST - Create a tag ```python -tag_client = team_client.get_tag_client(team_by_id) -create_tag = tag_client.create_tag(name="TestXsadasd", color="red") +def test_create_tag(self): + self.tag_obj = self.tag_client.create_tag(name=f"Tag name - {self.datetime_timestamp}", color="red") ``` #### GET - Get all tags ```python -get_all_tags = tag_client.get_all_tags() +def test_get_all_tags(self): + get_all_tags = self.tag_client.get_all_tags() ``` #### GET - GET tag by id ```python -get_tag = tag_client.get_tag_by_id(tags_id = ) +def test_get_tag_by_id(self): + get_tag = self.tag_client.get_tag_by_id(tags_id = self.tag_obj.unique_id) ``` #### PATCH - Update tag by id ```python -update_tag = tag_client(tag = , name="updated name", color="green") +def test_update_tag(self): + update_tag = self.tag_client.update_tag(tag=self.tag_obj, name="updated name", color="green") ``` #### DEL - Delete tag ```python -delete_tag = tag_client(tag = ) +def test_delete_tag(self): + delete_tag = self.tag_client.delete_tag(tag=self.tag_obj) ``` ## Task templates +```python +class SDKTemplateClient(SDKTeamsClient): + def __init__(self): + super().__init__() + self.teams_client = TeamsClient(client=self.client) + self.account_member_client = AccountMemberClient(client=self.client) + self.team_obj = self.teams_client.create_team(name=f"Integration Team - {self.datetime_timestamp}") + + self.tag_client = self.teams_client.get_tag_client(self.team_obj) + + self.task_template_client = self.teams_client.get_task_template_client(self.team_obj) +``` + #### POST - Create a task template ```python -task_template_client = team_client.get_task_template_client(team_by_id) -create_task_template = task_template_client.create_task_template( - name="Test Task Template", summary="Test Task Template" -) +def test_create_template(self): + self.task_template_obj = self.task_template_client.create_task_template( + name="Test Task Template", summary="Test Task Template" + ) ``` #### GET - Get all task templates ```python -get_all_task_templates = task_template_client.get_all_task_template() +def test_get_all_task_templates(self): + get_all_task_templates = self.task_template_client.get_all_task_template() ``` #### GET - Get task templates by id ```python -get_task_template_by_id = task_template_client.get_task_template_by_id( - task_template_id= -) +def test_get_task_template_by_id(self): + get_task_template_by_id = self.task_template_client.get_task_template_by_id( + task_template_id=self.task_template_obj.unique_id + ) ``` #### PATCH - Update the task template ```python -update_task_template = task_template_client.update_task_template( - task_template = , name="Test Task Template Updated" -) +def test_update_task_template(self): + update_task_template = self.task_template_client.update_task_template( + task_template = self.task_template_obj, name="Test Task Template Updated" + ) ``` #### DEL - Delete the task template ```python -delete_task_template = task_template_client.delete_task_template(task_template = ) +def test_delete_task_template(self): + delete_task_template = self.task_template_client.delete_task_template(task_template = self.task_template_obj) ``` # Running tests diff --git a/setup.py b/setup.py index 871a024..c8b3847 100644 --- a/setup.py +++ b/setup.py @@ -1,8 +1,8 @@ from setuptools import setup, find_packages setup( - name="zenduty-api-test", - version="1.0.1", + name="zenduty-api", + version="1.0.0", description="Python SDK wrapper for the Zenduty API", long_description=""" # Zenduty Python SDK diff --git a/test-pr-chcker b/test-pr-chcker deleted file mode 100644 index 16ecb83..0000000 --- a/test-pr-chcker +++ /dev/null @@ -1,5 +0,0 @@ -Hiii, PR check -PR Checker 2 -asdfasdfasdf -asdfasdfasdf -asdfasdfasdf - pr final check diff --git a/tests/test_sdk_automated.py b/tests/test_sdk_automated.py index ad0cdd0..42387fc 100644 --- a/tests/test_sdk_automated.py +++ b/tests/test_sdk_automated.py @@ -70,7 +70,6 @@ def delete_team(self): def test_create_team(self): # Team1 is the name of the team and that is the payload create_team = self.teams_client.create_team(self.test_team_name) - print("Here") self.team_ids.append(create_team) assert create_team.name == self.test_team_name time.sleep(2) @@ -80,6 +79,14 @@ def test_find_team_by_id(self): assert find_team.unique_id == self.team_ids[0].unique_id time.sleep(2) + def test_update_teams(self): + update_teams = self.teams_client.update_team( + self.team_ids[0], name=f"Updated Team Name - {self.datetime_timestamp}" + ) + assert ( + str(update_teams.name) == f"Updated Team Name - {self.datetime_timestamp}" + ) + def test_list_team_member(self): list_team_members = self.teams_client.list_team_members(self.team_ids[0]) assert list_team_members[0].team == self.team_ids[0].unique_id @@ -125,12 +132,6 @@ def update_team_permissions(self): ) assert "service_read" in updated_team_permissions - def test_update_teams(self): - update_teams = self.teams_client.update_team( - self.team_ids[0], name="Updated Team Name" - ) - assert str(update_teams.name) == "Updated Team Name" - def test_delete_teams(self): delete_teams = self.teams_client.delete_team(self.team_ids[0]) @@ -140,7 +141,8 @@ class TestSDKAccountMembersClient(TestSDKTeamsClient): @classmethod def setup_class(cls): super().setup_class() - cls.team_ids = [] + cls.account_member_obj = [] + cls.account_member_team_ids = [] cls.account_member_ids = [] cls.teams_client = TeamsClient(client=cls.client) cls.account_member_client = AccountMemberClient(client=cls.client) @@ -149,17 +151,18 @@ def test_account_members_invite(self): create_team = self.teams_client.create_team( name="Random Testing Team" + self.datetime_timestamp ) - self.team_ids.append(create_team.unique_id) + self.account_member_team_ids.append(create_team.unique_id) test_email = f"john.doe.{random.randint(2,10000000000000000000000)}@zenduty.com" account_member_invite = self.account_member_client.invite( - team_id=self.team_ids[0], + team_id=self.account_member_team_ids[0], first_name="John", last_name="doe", role=3, email=test_email, ) + self.account_member_obj.append(account_member_invite) self.account_member_ids.append(account_member_invite.user.username) assert account_member_invite.user.email == test_email @@ -167,7 +170,7 @@ def test_account_member_update(self): test_first_name = f"Jane {random.randint(2,10000000000000000000000)}" # updated the email update_account_member = self.account_member_client.update_account_member( - account_member_username=self.account_member_ids[0], + account_member=self.account_member_obj[0], first_name=test_first_name, last_name=f"Doe {random.randint(2,10000000000000000000000)}", role=2, @@ -186,7 +189,7 @@ def test_get_all_account_members(self): def test_delete_account_member(self): delete_account_member = self.account_member_client.delete_account_member( - account_member_id=self.account_member_ids[0] + account_member=self.account_member_obj[0] ) @@ -195,6 +198,7 @@ class TestSDKAccountRolesClient(SDKTestingClient): @classmethod def setup_class(cls): super().setup_class() + cls.account_role_obj = [] cls.account_role_ids = [] cls.account_role_client = AccountRoleClient(client=cls.client) @@ -206,6 +210,7 @@ def test_create_account_role(self): permissions=["sla_read"], ) + self.account_role_obj.append(create_account_role) self.account_role_ids.append(create_account_role.unique_id) assert create_account_role.name == test_name @@ -227,17 +232,18 @@ def test_list_account_roles(self): def test_update_account_role(self): test_name = f"Updated Account Role - {self.datetime_timestamp}" update_account_role = self.account_role_client.update_account_role( - account_role_id=self.account_role_ids[0], + account_role=self.account_role_obj[0], name=test_name, description="Updated Account Role Description", permissions=["sla_read"], ) + assert update_account_role.name == test_name time.sleep(2) def test_delete_account_role(self): delete_account_role = self.account_role_client.delete_account_role( - account_role_id=self.account_role_ids[0] + account_role=self.account_role_obj[0] ) time.sleep(2) @@ -248,6 +254,7 @@ class TestSDKGERClients(SDKTestingClient): def setup_class(cls): super().setup_class() cls.router_ids = [] + cls.router_obj = [] cls.router_client = RouterClient(client=cls.client) cls.router_name = f"Router - {cls.datetime_timestamp}" @@ -257,6 +264,7 @@ def test_create_router(self): description="Router Description", ) self.router_ids.append(create_router.unique_id) + self.router_obj.append(create_router) assert str(create_router.name) == f"Router - {self.datetime_timestamp}" time.sleep(2) @@ -268,14 +276,17 @@ def test_list_routers(self): break time.sleep(2) + def get_all_routers(self): + return self.router_client.get_all_routers() + def test_get_router_by_id(self): - find_router = self.router_client.get_router_by_id(router_id=self.router_ids[0]) + find_router = self.router_client.get_router_by_id(self.router_obj[0].unique_id) assert str(find_router.unique_id) == str(self.router_ids[0]) time.sleep(2) def test_update_router(self): update_router = self.router_client.update_router( - self.router_ids[0], + router=self.router_obj[0], name="Updated Router Name", description="Updated Router Description", ) @@ -284,7 +295,7 @@ def test_update_router(self): time.sleep(2) def test_delete_router(self): - delete_router = self.router_client.delete_router(self.router_ids[0]) + delete_router = self.router_client.delete_router(self.router_obj[0]) time.sleep(2) @@ -301,7 +312,6 @@ def test_get_router_client(self): get_router = self.event_client.get_router_client() def test_create_event(self): - create_event = self.event_client.create_event( integration_key="f86e6ade-f987-4cfc-b047-9ce9ca794b41", alert_type="info", @@ -335,10 +345,12 @@ def setup_class(cls): cls.escalation_policy_ids = [] cls.account_member_ids = [] cls.team_ids = [] + cls.create_escalation_policy_obj = [] cls.uuid = cls.generate_uuid() cls.teams_client = TeamsClient(client=cls.client) cls.account_member_client = AccountMemberClient(client=cls.client) cls.team_ids.append(cls.create_team(cls)) + # create teams fails because of this. cls.team_by_id = cls.teams_client.find_team_by_id( team_id="999a17ed-c7c3-4860-9024-d11c18fa5fa4" ) @@ -368,6 +380,7 @@ def test_create_escalation_policy(self): # Appending the unique_id to the escalation_policy_ids list self.escalation_policy_ids.append(create_escalation_policy.unique_id) + self.create_escalation_policy_obj.append(create_escalation_policy) assert create_escalation_policy.name == self.ep_name time.sleep(2) @@ -379,13 +392,22 @@ def test_get_esp_by_id(self): time.sleep(2) def test_update_esp(self): + self.rule_build = [ + { + "delay": 0, + "targets": [ + {"target_type": 2, "target_id": "3544118d-fbf5-41e5-ae6c-5"} + ], + "position": 1, + } + ] update_esp = self.escalation_policy_client.update_esp( - esp=self.get_esp_by_id, - name="Test Updated", + esp=self.create_escalation_policy_obj[0], + name=f"Test Updated - {self.datetime_timestamp}", rules=self.rule_build, ) - assert update_esp.name == "Test Updated" + assert update_esp.name == f"Test Updated - {self.datetime_timestamp}" time.sleep(2) def test_get_all_policies(self): @@ -393,7 +415,9 @@ def test_get_all_policies(self): time.sleep(2) def test_delete_esp(self): - delete_esp = self.escalation_policy_client.delete_esp(esp=self.get_esp_by_id) + delete_esp = self.escalation_policy_client.delete_esp( + esp=self.create_escalation_policy_obj[0] + ) time.sleep(2) @@ -405,6 +429,7 @@ def setup_class(cls): cls.maintenance_ids = [] cls.account_member_ids = [] cls.team_ids = [] + cls.maintenance_obj = [] cls.uuid = cls.generate_uuid() cls.teams_client = TeamsClient(client=cls.client) cls.team_ids.append(cls.create_team(cls)) @@ -421,7 +446,7 @@ def test_create_maintenance(self): end_time="2026-07-08T18:06:00", service_ids=["a91a3a00-8de9-472c-ad2e-61e7c89db062"], ) - + self.maintenance_obj.append(create_maintenance) self.maintenance_ids.append(create_maintenance.unique_id) assert create_maintenance.name == self.maintenance_name time.sleep(2) @@ -438,9 +463,9 @@ def test_get_maintenance_by_id(self): time.sleep(2) - def test_update_maintenance_by_id(self): + def test_update_maintenance(self): update_maintenance = self.maintenance_client.update_maintenance( - maintenance_id=self.maintenance_ids[0], + maintenance=self.maintenance_obj[0], name="Updated Maintenance Name", start_time="2026-07-08T18:06:00", end_time="2026-07-08T18:06:00", @@ -451,7 +476,7 @@ def test_update_maintenance_by_id(self): def test_delete_maintenance(self): delete_maintenance = self.maintenance_client.delete_maintenance( - maintenance_id=self.maintenance_ids[0] + maintenance=self.maintenance_obj[0] ) time.sleep(2) @@ -489,7 +514,7 @@ def test_create_incident(self): def test_create_incident_note(self): # Creating a Incident Note client self.note_client = self.incident_client.get_note_client( - incident_id=self.incident_ids[0] + incident=self.incident_obj ) # Creating an incident note, attaching it to an incident @@ -508,20 +533,20 @@ def test_get_all_incident_notes(self): def test_get_incident_note_by_id(self): get_incident_note_by_id = self.note_client.get_incident_note_by_id( - incident_note_unique_id=self.incident_notes_list[0] + incident_note_unique_id=self.incident_note_obj.unique_id ) time.sleep(2) # get this checked tomorrow def test_update_incident_note(self): update_incident_note = self.note_client.update_incident_note( - incident_note_unique_id=self.incident_notes_list[0], + incident_note=self.incident_note_obj, note="Updated Incident Note", ) def test_delete_incident_note(self): delete_incident_note = self.note_client.delete_incident_note( - incident_note_unique_id=self.incident_notes_list[0] + incident_note=self.incident_note_obj ) # get this checked tomorrow @@ -552,13 +577,13 @@ def test_get_all_incidents(self): def test_get_alerts_by_incident(self): get_alerts_by_incident = self.incident_client.get_alerts_for_incident( - incident_number=self.incident_number[0] + incident_number=self.incident_obj.incident_number ) time.sleep(2) def test_update_incident(self): update_incident = self.incident_client.update_incident( - incident_id=self.incident_ids[0], + incident_id=self.incident_obj.unique_id, title="Updated Incident Name", status=3, service="a91a3a00-8de9-472c-ad2e-61e7c89db062", @@ -633,7 +658,7 @@ def test_delete_postmortem(self): # Resolve the incident resolve_incident = self.incident_client.update_incident( - incident_id=self.incident_ids[0], + self.postmortem_obj, title=self.incident_name, status=3, ) @@ -680,7 +705,7 @@ def test_get_priority_by_id(self): def test_update_priority(self): update_priority = self.priority_client.update_priority( - self.priority_by_id, + self.priority_obj, name="Test Priority Updated", description="Test Priority", ) @@ -689,7 +714,7 @@ def test_update_priority(self): time.sleep(2) def test_delete_priority(self): - delete_priority = self.priority_client.delete_priority(self.priority_ids[0]) + delete_priority = self.priority_client.delete_priority(self.priority_obj) time.sleep(2) @@ -730,7 +755,7 @@ def test_get_incident_role_by_id(self): def test_update_incident_role(self): self.update_role = self.role_client.update_incident_role( - role=self.get_role_by_id, + role=self.role_obj, title="Test Role Updated", ) assert self.update_role.title == "Test Role Updated" @@ -738,7 +763,7 @@ def test_update_incident_role(self): def test_delete_incident_role(self): self.delete_role = self.role_client.delete_incident_role( - role=self.get_role_by_id + role=self.role_obj, ) time.sleep(2) @@ -751,6 +776,7 @@ def setup_class(cls): cls.team_ids = [] cls.schedules_ids = [] cls.account_member_ids = [] + cls.schedules_obj = [] cls.uuid = cls.generate_uuid() cls.teams_client = TeamsClient(client=cls.client) cls.team_ids.append(cls.create_team(cls)) @@ -795,6 +821,7 @@ def test_create_schedule(self): ) self.schedules_ids.append(create_schedule.unique_id) + self.schedules_obj.append(create_schedule) assert create_schedule.name == self.schedules_name time.sleep(2) @@ -812,14 +839,14 @@ def test_get_schedule_by_id(self): def test_update_schedule(self): update_schedule = self.schedules_client.update_schedule( - schedule=self.get_schedule_by_id, + schedule=self.schedules_obj[0], name="Test Schedule Updated", ) assert update_schedule.name == "Test Schedule Updated" def test_delete_schedule(self): delete_schedule = self.schedules_client.delete_schedule( - schedule=self.get_schedule_by_id + schedule=self.schedules_obj[0] ) @@ -897,135 +924,3 @@ def test_create_service(self): team_priority=str(self.priority_ids[0]), sla=str(self.sla_ids[0]), ) - - -@pytest.mark.integrations -class TestSDKIntegrationClient(TestSDKServicesClient): - @classmethod - def setup_class(cls): - super().setup_class() - cls.service_ids = [] - integration_client = cls.service_client.get_integration_client( - svc=cls.service_ids[0] - ) - - -@pytest.mark.sla -class TestSDKSLAClient(SDKTestingClient): - pass - - -@pytest.mark.tags -class TestSDKTagsClient(SDKTestingClient): - pass - - -@pytest.mark.tasktemplates -class TestSDKTaskTemplatesClient(SDKTestingClient): - pass - - -if __name__ == "__main__": - # escalations_client = TestSDKEscalationPolicyClient() - # escalations_client.test_create_escalation_policy() - - teams_client = TestSDKTeamsClient() - teams_client.test_create_team() - teams_client.test_find_team_by_id() - teams_client.test_list_team_member() - teams_client.test_add_team_member() - teams_client.test_find_team_member() - teams_client.test_update_team_member() - teams_client.test_delete_team_member() - teams_client.test_fetch_team_permissions() - teams_client.update_team_permissions() - teams_client.test_update_teams() - teams_client.test_delete_teams() - - # router_client = TestSDKGERClients() - # router_client.test_create_router() - # router_client.test_list_routers() - # router_client.test_get_router_by_id() - # router_client.test_update_router() - # router_client.test_delete_router() - - # account_members = TestSDKAccountMembersClient() - # account_members.test_account_members_invite() - # account_members.test_account_member_update() - # account_members.test_get_account_member() - # account_members.test_get_all_account_members() - # account_members.test_delete_account_member() - - # account_role = TestSDKAccountRolesClient() - # account_role.test_create_account_role() - # account_role.test_get_account_role() - # account_role.test_list_account_roles() - # account_role.test_update_account_role() - # account_role.test_delete_account_role() - - # event = TestSDKEventsClient() - # event.test_get_router_client() - # event.test_create_event() - - # incidents = TestSDKIncidentsClient() - # incidents.test_create_incident() - # incidents.test_get_all_incidents() - # incidents.test_get_alerts_by_incident() - # incidents.test_update_incident() - - # incidents.test_create_incident_note() - # incidents.test_get_all_incident_notes() - # # get this checked tomorrow - # # incidents.test_get_incident_note_by_id() - # incidents.test_update_incident_note() - # incidents.test_delete_incident_note() - # # get this checked tomorrow - all of these below - # incidents.test_create_incident_tag() - # incidents.test_get_all_tags() - # incidents.test_get_tag_by_id() - # incidents.test_delete_incident_tag() - - # escalations_client = TestSDKEscalationPolicyClient() - # escalations_client.test_create_escalation_policy() - # escalations_client.test_get_esp_by_id() - # escalations_client.test_update_esp() - # escalations_client.test_get_all_policies() - # escalations_client.test_delete_esp() - - # Run this, and ask what is "Maintenance_Template" - # add Maintenance_Template to the model - # maintenance_client = TestSDKMaintenanceClient() - # maintenance_client.test_create_maintenance() - # maintenance_client.test_get_all_maintenance() - # maintenance_client.test_get_maintenance_by_id() - # maintenance_client.test_update_maintenance_by_id() - # maintenance_client.test_delete_maintenance() - - # postmortem_client = TestSDKPostMortemClient() - # postmortem_client.test_create_postmortem() - # postmortem_client.test_get_postmortem_by_id() - # postmortem_client.test_update_postmortem() - # postmortem_client.test_delete_postmortem() - - # priority_client = TestSDKPrioritiesClient() - # priority_client.test_create_priority() - # priority_client.test_get_all_priorities() - # priority_client.test_get_priority_by_id() - # priority_client.test_update_priority() - # priority_client.test_delete_priority() - - # roles_client = TestSDKRolesClient() - # roles_client.test_create_role() - # roles_client.test_get_incident_role_by_id() - # roles_client.test_update_incident_role() - # roles_client.test_delete_incident_role() - - # schedules_client = TestSDKSchedulesClient() - # schedules_client.test_create_schedule() - # schedules_client.test_get_all_schedules() - # schedules_client.test_get_schedule_by_id() - # schedules_client.test_update_schedule() - # schedules_client.test_delete_schedule() - - # services_client = TestSDKServicesClient() - # services_client.test_create_service() diff --git a/zenduty/apiV2/teams/maintenance/models.py b/zenduty/apiV2/teams/maintenance/models.py index 4643973..6b132de 100644 --- a/zenduty/apiV2/teams/maintenance/models.py +++ b/zenduty/apiV2/teams/maintenance/models.py @@ -23,6 +23,7 @@ class TeamMaintenance(JsonSerializable): name: str time_zone: str repeat_until: Optional[datetime] + maintenance_template: str def __init__( self, @@ -35,6 +36,7 @@ def __init__( name: str, time_zone: str, repeat_until: Optional[int], + maintenance_template: str, ) -> None: self.unique_id = unique_id if type(unique_id) is not str else UUID(unique_id) self.start_time = ( @@ -66,3 +68,4 @@ def __init__( if type(repeat_until) is datetime or repeat_until is None else datetime.fromisoformat(repeat_until.replace("Z", "+00:00")) ) + self.maintenance_template = maintenance_template