From bc59267ac50938eaa633c1e4e7f72e9e9a2225f4 Mon Sep 17 00:00:00 2001 From: Sirija Reddy Date: Wed, 3 Sep 2025 23:17:59 +0530 Subject: [PATCH] fix : Add integration tests for Rulesets Signed-off-by: Sirija Reddy --- ibm_cloud_networking_services/rulesets_v1.py | 3887 +++++++++++++++ test/integration/test_rulesets_v1.py | 926 ++++ test/unit/test_rulesets_v1.py | 4470 ++++++++++++++++++ 3 files changed, 9283 insertions(+) create mode 100644 ibm_cloud_networking_services/rulesets_v1.py create mode 100644 test/integration/test_rulesets_v1.py create mode 100644 test/unit/test_rulesets_v1.py diff --git a/ibm_cloud_networking_services/rulesets_v1.py b/ibm_cloud_networking_services/rulesets_v1.py new file mode 100644 index 0000000..e3fb3fd --- /dev/null +++ b/ibm_cloud_networking_services/rulesets_v1.py @@ -0,0 +1,3887 @@ +# coding: utf-8 + +# (C) Copyright IBM Corp. 2025. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# IBM OpenAPI SDK Code Generator Version: 3.106.0-09823488-20250707-071701 + +""" +Rulesets Engine + +API Version: 1.0.1 +""" + +from enum import Enum +from typing import Dict, List, Optional +import json + +from ibm_cloud_sdk_core import BaseService, DetailedResponse +from ibm_cloud_sdk_core.authenticators.authenticator import Authenticator +from ibm_cloud_sdk_core.get_authenticator import get_authenticator_from_environment +from ibm_cloud_sdk_core.utils import convert_model + +from .common import get_sdk_headers + +############################################################################## +# Service +############################################################################## + + +class RulesetsV1(BaseService): + """The Rulesets V1 service.""" + + DEFAULT_SERVICE_URL = 'https://api.cis.cloud.ibm.com' + DEFAULT_SERVICE_NAME = 'rulesets' + + @classmethod + def new_instance( + cls, + crn: str, + zone_identifier: str, + service_name: str = DEFAULT_SERVICE_NAME, + ) -> 'RulesetsV1': + """ + Return a new client for the Rulesets service using the specified parameters + and external configuration. + + :param str crn: Full url-encoded CRN of the service instance. + + :param str zone_identifier: zone identifier. + """ + if crn is None: + raise ValueError('crn must be provided') + if zone_identifier is None: + raise ValueError('zone_identifier must be provided') + + authenticator = get_authenticator_from_environment(service_name) + service = cls( + crn, + zone_identifier, + authenticator + ) + service.configure_service(service_name) + return service + + def __init__( + self, + crn: str, + zone_identifier: str, + authenticator: Authenticator = None, + ) -> None: + """ + Construct a new client for the Rulesets service. + + :param str crn: Full url-encoded CRN of the service instance. + + :param str zone_identifier: zone identifier. + + :param Authenticator authenticator: The authenticator specifies the authentication mechanism. + Get up to date information from https://github.com/IBM/python-sdk-core/blob/main/README.md + about initializing the authenticator of your choice. + """ + if crn is None: + raise ValueError('crn must be provided') + if zone_identifier is None: + raise ValueError('zone_identifier must be provided') + + BaseService.__init__(self, service_url=self.DEFAULT_SERVICE_URL, authenticator=authenticator) + self.crn = crn + self.zone_identifier = zone_identifier + + ######################### + # Instance Rulesets + ######################### + + def get_instance_rulesets( + self, + **kwargs, + ) -> DetailedResponse: + """ + List Instance rulesets. + + List all rulesets at the instance level. + + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_rulesets', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn'] + path_param_values = self.encode_path_vars(self.crn) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_ruleset( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Get an instance ruleset. + + View a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def update_instance_ruleset( + self, + ruleset_id: str, + *, + description: Optional[str] = None, + kind: Optional[str] = None, + name: Optional[str] = None, + phase: Optional[str] = None, + rules: Optional[List['RuleCreate']] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update an instance ruleset. + + Update a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str description: (optional) description of the ruleset. + :param str kind: (optional) + :param str name: (optional) human readable name of the ruleset. + :param str phase: (optional) The phase of the ruleset. + :param List[RuleCreate] rules: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if rules is not None: + rules = [convert_model(x) for x in rules] + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_instance_ruleset', + ) + headers.update(sdk_headers) + + data = { + 'description': description, + 'kind': kind, + 'name': name, + 'phase': phase, + 'rules': rules, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='PUT', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def delete_instance_ruleset( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete an instance ruleset. + + Delete a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_instance_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + + path_param_keys = ['crn', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_ruleset_versions( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + List version of an instance ruleset. + + List all versions of a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_ruleset_versions', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/versions'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_ruleset_version( + self, + ruleset_id: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Get a specific version of an instance ruleset. + + View a specific version of a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def delete_instance_ruleset_version( + self, + ruleset_id: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete a specific version of an instance ruleset. + + Delete a specific version of a specific instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_instance_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + + path_param_keys = ['crn', 'ruleset_id', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_entrypoint_ruleset( + self, + ruleset_phase: str, + **kwargs, + ) -> DetailedResponse: + """ + Get an instance entrypoint ruleset. + + Get the instance ruleset for the given phase's entrypoint. + + :param str ruleset_phase: The phase of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_entrypoint_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/phases/{ruleset_phase}/entrypoint'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def update_instance_entrypoint_ruleset( + self, + ruleset_phase: str, + *, + description: Optional[str] = None, + kind: Optional[str] = None, + name: Optional[str] = None, + phase: Optional[str] = None, + rules: Optional[List['RuleCreate']] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update an instance entrypoint ruleset. + + Updates the instance ruleset for the given phase's entry point. + + :param str ruleset_phase: The phase of the ruleset. + :param str description: (optional) description of the ruleset. + :param str kind: (optional) + :param str name: (optional) human readable name of the ruleset. + :param str phase: (optional) The phase of the ruleset. + :param List[RuleCreate] rules: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + if rules is not None: + rules = [convert_model(x) for x in rules] + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_instance_entrypoint_ruleset', + ) + headers.update(sdk_headers) + + data = { + 'description': description, + 'kind': kind, + 'name': name, + 'phase': phase, + 'rules': rules, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/phases/{ruleset_phase}/entrypoint'.format(**path_param_dict) + request = self.prepare_request( + method='PUT', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_entry_point_ruleset_versions( + self, + ruleset_phase: str, + **kwargs, + ) -> DetailedResponse: + """ + List an instance entry point ruleset's versions. + + Lists the instance ruleset versions for the given phase's entry point. + + :param str ruleset_phase: The phase of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_entry_point_ruleset_versions', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/phases/{ruleset_phase}/entrypoint/versions'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_entry_point_ruleset_version( + self, + ruleset_phase: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Get an instance entry point ruleset version. + + Fetches a specific version of an instance entry point ruleset. + + :param str ruleset_phase: The phase of the ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_entry_point_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_phase', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, ruleset_phase, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/phases/{ruleset_phase}/entrypoint/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def create_instance_ruleset_rule( + self, + ruleset_id: str, + *, + action: Optional[str] = None, + expression: Optional[str] = None, + action_parameters: Optional['ActionParameters'] = None, + ratelimit: Optional['Ratelimit'] = None, + description: Optional[str] = None, + enabled: Optional[bool] = None, + id: Optional[str] = None, + logging: Optional['Logging'] = None, + ref: Optional[str] = None, + position: Optional['Position'] = None, + **kwargs, + ) -> DetailedResponse: + """ + Create an instance ruleset rule. + + Create an instance ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param str expression: (optional) The expression defining which traffic + will match the rule. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Position position: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if action_parameters is not None: + action_parameters = convert_model(action_parameters) + if ratelimit is not None: + ratelimit = convert_model(ratelimit) + if logging is not None: + logging = convert_model(logging) + if position is not None: + position = convert_model(position) + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='create_instance_ruleset_rule', + ) + headers.update(sdk_headers) + + data = { + 'action': action, + 'expression': expression, + 'action_parameters': action_parameters, + 'ratelimit': ratelimit, + 'description': description, + 'enabled': enabled, + 'id': id, + 'logging': logging, + 'ref': ref, + 'position': position, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/rules'.format(**path_param_dict) + request = self.prepare_request( + method='POST', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def update_instance_ruleset_rule( + self, + ruleset_id: str, + rule_id: str, + *, + action: Optional[str] = None, + action_parameters: Optional['ActionParameters'] = None, + ratelimit: Optional['Ratelimit'] = None, + description: Optional[str] = None, + enabled: Optional[bool] = None, + expression: Optional[str] = None, + id: Optional[str] = None, + logging: Optional['Logging'] = None, + ref: Optional[str] = None, + position: Optional['Position'] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update an instance ruleset rule. + + Update an instance ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str rule_id: ID of a specific rule. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str expression: (optional) The expression defining which traffic + will match the rule. + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Position position: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not rule_id: + raise ValueError('rule_id must be provided') + if action_parameters is not None: + action_parameters = convert_model(action_parameters) + if ratelimit is not None: + ratelimit = convert_model(ratelimit) + if logging is not None: + logging = convert_model(logging) + if position is not None: + position = convert_model(position) + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_instance_ruleset_rule', + ) + headers.update(sdk_headers) + + data = { + 'action': action, + 'action_parameters': action_parameters, + 'ratelimit': ratelimit, + 'description': description, + 'enabled': enabled, + 'expression': expression, + 'id': id, + 'logging': logging, + 'ref': ref, + 'position': position, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id', 'rule_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id, rule_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/rules/{rule_id}'.format(**path_param_dict) + request = self.prepare_request( + method='PATCH', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def delete_instance_ruleset_rule( + self, + ruleset_id: str, + rule_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete an instance ruleset rule. + + Delete an instance ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str rule_id: ID of a specific rule. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RuleResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not rule_id: + raise ValueError('rule_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_instance_ruleset_rule', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id', 'rule_id'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id, rule_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/rules/{rule_id}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_instance_ruleset_version_by_tag( + self, + ruleset_id: str, + ruleset_version: str, + rule_tag: str, + **kwargs, + ) -> DetailedResponse: + """ + List an instance ruleset verion's rules by tag. + + Lists rules by tag for a specific version of an instance ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str ruleset_version: The version of the ruleset. + :param str rule_tag: A category of the rule. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + if not rule_tag: + raise ValueError('rule_tag must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_instance_ruleset_version_by_tag', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'ruleset_id', 'ruleset_version', 'rule_tag'] + path_param_values = self.encode_path_vars(self.crn, ruleset_id, ruleset_version, rule_tag) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/rulesets/{ruleset_id}/versions/{ruleset_version}/by_tag/{rule_tag}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + ######################### + # Zone Rulesets + ######################### + + def get_zone_rulesets( + self, + **kwargs, + ) -> DetailedResponse: + """ + List zone rulesets. + + List all rulesets at the zone level. + + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_rulesets', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_ruleset( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Get a zone ruleset. + + View a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def update_zone_ruleset( + self, + ruleset_id: str, + *, + description: Optional[str] = None, + kind: Optional[str] = None, + name: Optional[str] = None, + phase: Optional[str] = None, + rules: Optional[List['RuleCreate']] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update a zone ruleset. + + Update a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str description: (optional) description of the ruleset. + :param str kind: (optional) + :param str name: (optional) human readable name of the ruleset. + :param str phase: (optional) The phase of the ruleset. + :param List[RuleCreate] rules: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if rules is not None: + rules = [convert_model(x) for x in rules] + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_zone_ruleset', + ) + headers.update(sdk_headers) + + data = { + 'description': description, + 'kind': kind, + 'name': name, + 'phase': phase, + 'rules': rules, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='PUT', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def delete_zone_ruleset( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete a zone ruleset. + + Delete a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_zone_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_ruleset_versions( + self, + ruleset_id: str, + **kwargs, + ) -> DetailedResponse: + """ + List version of a zone ruleset. + + List all versions of a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_ruleset_versions', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/versions'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_ruleset_version( + self, + ruleset_id: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Get a specific version of a zone ruleset. + + View a specific version of a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def delete_zone_ruleset_version( + self, + ruleset_id: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete a specific version of a zone ruleset. + + Delete a specific version of a specific zone ruleset. + + :param str ruleset_id: ID of a specific ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_zone_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_entrypoint_ruleset( + self, + ruleset_phase: str, + **kwargs, + ) -> DetailedResponse: + """ + Get a zone entrypoint ruleset. + + Get the zone ruleset for the given phase's entrypoint. + + :param str ruleset_phase: The phase of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_entrypoint_ruleset', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/phases/{ruleset_phase}/entrypoint'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def update_zone_entrypoint_ruleset( + self, + ruleset_phase: str, + *, + description: Optional[str] = None, + kind: Optional[str] = None, + name: Optional[str] = None, + phase: Optional[str] = None, + rules: Optional[List['RuleCreate']] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update a zone entrypoint ruleset. + + Updates the instance ruleset for the given phase's entry point. + + :param str ruleset_phase: The phase of the ruleset. + :param str description: (optional) description of the ruleset. + :param str kind: (optional) + :param str name: (optional) human readable name of the ruleset. + :param str phase: (optional) The phase of the ruleset. + :param List[RuleCreate] rules: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + if rules is not None: + rules = [convert_model(x) for x in rules] + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_zone_entrypoint_ruleset', + ) + headers.update(sdk_headers) + + data = { + 'description': description, + 'kind': kind, + 'name': name, + 'phase': phase, + 'rules': rules, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/phases/{ruleset_phase}/entrypoint'.format(**path_param_dict) + request = self.prepare_request( + method='PUT', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_entry_point_ruleset_versions( + self, + ruleset_phase: str, + **kwargs, + ) -> DetailedResponse: + """ + List a zone entry point ruleset's versions. + + Lists the zone ruleset versions for the given phase's entry point. + + :param str ruleset_phase: The phase of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `ListRulesetsResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_entry_point_ruleset_versions', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_phase'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_phase) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/phases/{ruleset_phase}/entrypoint/versions'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def get_zone_entry_point_ruleset_version( + self, + ruleset_phase: str, + ruleset_version: str, + **kwargs, + ) -> DetailedResponse: + """ + Get a zone entry point ruleset version. + + Fetches a specific version of a zone entry point ruleset. + + :param str ruleset_phase: The phase of the ruleset. + :param str ruleset_version: The version of the ruleset. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_phase: + raise ValueError('ruleset_phase must be provided') + if not ruleset_version: + raise ValueError('ruleset_version must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='get_zone_entry_point_ruleset_version', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_phase', 'ruleset_version'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_phase, ruleset_version) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/phases/{ruleset_phase}/entrypoint/versions/{ruleset_version}'.format(**path_param_dict) + request = self.prepare_request( + method='GET', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + def create_zone_ruleset_rule( + self, + ruleset_id: str, + *, + action: Optional[str] = None, + expression: Optional[str] = None, + action_parameters: Optional['ActionParameters'] = None, + ratelimit: Optional['Ratelimit'] = None, + description: Optional[str] = None, + enabled: Optional[bool] = None, + id: Optional[str] = None, + logging: Optional['Logging'] = None, + ref: Optional[str] = None, + position: Optional['Position'] = None, + **kwargs, + ) -> DetailedResponse: + """ + Create a zone ruleset rule. + + Create a zone ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param str expression: (optional) The expression defining which traffic + will match the rule. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Position position: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if action_parameters is not None: + action_parameters = convert_model(action_parameters) + if ratelimit is not None: + ratelimit = convert_model(ratelimit) + if logging is not None: + logging = convert_model(logging) + if position is not None: + position = convert_model(position) + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='create_zone_ruleset_rule', + ) + headers.update(sdk_headers) + + data = { + 'action': action, + 'expression': expression, + 'action_parameters': action_parameters, + 'ratelimit': ratelimit, + 'description': description, + 'enabled': enabled, + 'id': id, + 'logging': logging, + 'ref': ref, + 'position': position, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/rules'.format(**path_param_dict) + request = self.prepare_request( + method='POST', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def update_zone_ruleset_rule( + self, + ruleset_id: str, + rule_id: str, + *, + action: Optional[str] = None, + action_parameters: Optional['ActionParameters'] = None, + ratelimit: Optional['Ratelimit'] = None, + description: Optional[str] = None, + enabled: Optional[bool] = None, + expression: Optional[str] = None, + id: Optional[str] = None, + logging: Optional['Logging'] = None, + ref: Optional[str] = None, + position: Optional['Position'] = None, + **kwargs, + ) -> DetailedResponse: + """ + Update a zone ruleset rule. + + Update a zone ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str rule_id: ID of a specific rule. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str expression: (optional) The expression defining which traffic + will match the rule. + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Position position: (optional) + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RulesetResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not rule_id: + raise ValueError('rule_id must be provided') + if action_parameters is not None: + action_parameters = convert_model(action_parameters) + if ratelimit is not None: + ratelimit = convert_model(ratelimit) + if logging is not None: + logging = convert_model(logging) + if position is not None: + position = convert_model(position) + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='update_zone_ruleset_rule', + ) + headers.update(sdk_headers) + + data = { + 'action': action, + 'action_parameters': action_parameters, + 'ratelimit': ratelimit, + 'description': description, + 'enabled': enabled, + 'expression': expression, + 'id': id, + 'logging': logging, + 'ref': ref, + 'position': position, + } + data = {k: v for (k, v) in data.items() if v is not None} + data = json.dumps(data) + headers['content-type'] = 'application/json' + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id', 'rule_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id, rule_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/rules/{rule_id}'.format(**path_param_dict) + request = self.prepare_request( + method='PATCH', + url=url, + headers=headers, + data=data, + ) + + response = self.send(request, **kwargs) + return response + + def delete_zone_ruleset_rule( + self, + ruleset_id: str, + rule_id: str, + **kwargs, + ) -> DetailedResponse: + """ + Delete a zone ruleset rule. + + Delete an instance ruleset rule. + + :param str ruleset_id: ID of a specific ruleset. + :param str rule_id: ID of a specific rule. + :param dict headers: A `dict` containing the request headers + :return: A `DetailedResponse` containing the result, headers and HTTP status code. + :rtype: DetailedResponse with `dict` result representing a `RuleResp` object + """ + + if not ruleset_id: + raise ValueError('ruleset_id must be provided') + if not rule_id: + raise ValueError('rule_id must be provided') + headers = {} + sdk_headers = get_sdk_headers( + service_name=self.DEFAULT_SERVICE_NAME, + service_version='V1', + operation_id='delete_zone_ruleset_rule', + ) + headers.update(sdk_headers) + + if 'headers' in kwargs: + headers.update(kwargs.get('headers')) + del kwargs['headers'] + headers['Accept'] = 'application/json' + + path_param_keys = ['crn', 'zone_identifier', 'ruleset_id', 'rule_id'] + path_param_values = self.encode_path_vars(self.crn, self.zone_identifier, ruleset_id, rule_id) + path_param_dict = dict(zip(path_param_keys, path_param_values)) + url = '/v1/{crn}/zones/{zone_identifier}/rulesets/{ruleset_id}/rules/{rule_id}'.format(**path_param_dict) + request = self.prepare_request( + method='DELETE', + url=url, + headers=headers, + ) + + response = self.send(request, **kwargs) + return response + + +class GetInstanceEntrypointRulesetEnums: + """ + Enums for get_instance_entrypoint_ruleset parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class UpdateInstanceEntrypointRulesetEnums: + """ + Enums for update_instance_entrypoint_ruleset parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class GetInstanceEntryPointRulesetVersionsEnums: + """ + Enums for get_instance_entry_point_ruleset_versions parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class GetInstanceEntryPointRulesetVersionEnums: + """ + Enums for get_instance_entry_point_ruleset_version parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class GetZoneEntrypointRulesetEnums: + """ + Enums for get_zone_entrypoint_ruleset parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class UpdateZoneEntrypointRulesetEnums: + """ + Enums for update_zone_entrypoint_ruleset parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class GetZoneEntryPointRulesetVersionsEnums: + """ + Enums for get_zone_entry_point_ruleset_versions parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +class GetZoneEntryPointRulesetVersionEnums: + """ + Enums for get_zone_entry_point_ruleset_version parameters. + """ + + class RulesetPhase(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + +############################################################################## +# Models +############################################################################## + + +class ActionParametersResponse: + """ + ActionParametersResponse. + + :param str content: the content to return. + :param str content_type: + :param int status_code: The status code to return. + """ + + def __init__( + self, + content: str, + content_type: str, + status_code: int, + ) -> None: + """ + Initialize a ActionParametersResponse object. + + :param str content: the content to return. + :param str content_type: + :param int status_code: The status code to return. + """ + self.content = content + self.content_type = content_type + self.status_code = status_code + + @classmethod + def from_dict(cls, _dict: Dict) -> 'ActionParametersResponse': + """Initialize a ActionParametersResponse object from a json dictionary.""" + args = {} + content = _dict.get('content') + if content is not None: + args['content'] = content + else: + raise ValueError('Required property \'content\' not present in ActionParametersResponse JSON') + content_type = _dict.get('content_type') + if content_type is not None: + args['content_type'] = content_type + else: + raise ValueError('Required property \'content_type\' not present in ActionParametersResponse JSON') + status_code = _dict.get('status_code') + if status_code is not None: + args['status_code'] = status_code + else: + raise ValueError('Required property \'status_code\' not present in ActionParametersResponse JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a ActionParametersResponse object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'content') and self.content is not None: + _dict['content'] = self.content + if hasattr(self, 'content_type') and self.content_type is not None: + _dict['content_type'] = self.content_type + if hasattr(self, 'status_code') and self.status_code is not None: + _dict['status_code'] = self.status_code + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this ActionParametersResponse object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'ActionParametersResponse') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'ActionParametersResponse') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class MessageSource: + """ + The source of this message. + + :param str pointer: A JSON pointer to the field that is the source of the + message. + """ + + def __init__( + self, + pointer: str, + ) -> None: + """ + Initialize a MessageSource object. + + :param str pointer: A JSON pointer to the field that is the source of the + message. + """ + self.pointer = pointer + + @classmethod + def from_dict(cls, _dict: Dict) -> 'MessageSource': + """Initialize a MessageSource object from a json dictionary.""" + args = {} + pointer = _dict.get('pointer') + if pointer is not None: + args['pointer'] = pointer + else: + raise ValueError('Required property \'pointer\' not present in MessageSource JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a MessageSource object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'pointer') and self.pointer is not None: + _dict['pointer'] = self.pointer + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this MessageSource object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'MessageSource') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'MessageSource') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class ActionParameters: + """ + ActionParameters. + + :param str id: (optional) unique ID of the ruleset. + :param Overrides overrides: (optional) + :param str version: (optional) The version of the ruleset. Use "latest" to get + the latest version. + :param str ruleset: (optional) Ruleset ID of the ruleset to apply action to. Use + "current" to apply to the current ruleset. + :param List[str] rulesets: (optional) List of ruleset ids to apply action to. + Use "current" to apply to the current ruleset. + :param List[str] phases: (optional) Skips the execution of one or more phases. + :param List[str] products: (optional) Skips specific security products that are + not based on the Ruleset Engine. + :param ActionParametersResponse response: (optional) + """ + + def __init__( + self, + *, + id: Optional[str] = None, + overrides: Optional['Overrides'] = None, + version: Optional[str] = None, + ruleset: Optional[str] = None, + rulesets: Optional[List[str]] = None, + phases: Optional[List[str]] = None, + products: Optional[List[str]] = None, + response: Optional['ActionParametersResponse'] = None, + ) -> None: + """ + Initialize a ActionParameters object. + + :param str id: (optional) unique ID of the ruleset. + :param Overrides overrides: (optional) + :param str version: (optional) The version of the ruleset. Use "latest" to + get the latest version. + :param str ruleset: (optional) Ruleset ID of the ruleset to apply action + to. Use "current" to apply to the current ruleset. + :param List[str] rulesets: (optional) List of ruleset ids to apply action + to. Use "current" to apply to the current ruleset. + :param List[str] phases: (optional) Skips the execution of one or more + phases. + :param List[str] products: (optional) Skips specific security products that + are not based on the Ruleset Engine. + :param ActionParametersResponse response: (optional) + """ + self.id = id + self.overrides = overrides + self.version = version + self.ruleset = ruleset + self.rulesets = rulesets + self.phases = phases + self.products = products + self.response = response + + @classmethod + def from_dict(cls, _dict: Dict) -> 'ActionParameters': + """Initialize a ActionParameters object from a json dictionary.""" + args = {} + id = _dict.get('id') + if id is not None: + args['id'] = id + overrides = _dict.get('overrides') + if overrides is not None: + args['overrides'] = Overrides.from_dict(overrides) + version = _dict.get('version') + if version is not None: + args['version'] = version + ruleset = _dict.get('ruleset') + if ruleset is not None: + args['ruleset'] = ruleset + rulesets = _dict.get('rulesets') + if rulesets is not None: + args['rulesets'] = rulesets + phases = _dict.get('phases') + if phases is not None: + args['phases'] = phases + products = _dict.get('products') + if products is not None: + args['products'] = products + response = _dict.get('response') + if response is not None: + args['response'] = ActionParametersResponse.from_dict(response) + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a ActionParameters object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'overrides') and self.overrides is not None: + if isinstance(self.overrides, dict): + _dict['overrides'] = self.overrides + else: + _dict['overrides'] = self.overrides.to_dict() + if hasattr(self, 'version') and self.version is not None: + _dict['version'] = self.version + if hasattr(self, 'ruleset') and self.ruleset is not None: + _dict['ruleset'] = self.ruleset + if hasattr(self, 'rulesets') and self.rulesets is not None: + _dict['rulesets'] = self.rulesets + if hasattr(self, 'phases') and self.phases is not None: + _dict['phases'] = self.phases + if hasattr(self, 'products') and self.products is not None: + _dict['products'] = self.products + if hasattr(self, 'response') and self.response is not None: + if isinstance(self.response, dict): + _dict['response'] = self.response + else: + _dict['response'] = self.response.to_dict() + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this ActionParameters object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'ActionParameters') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'ActionParameters') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class CategoriesOverride: + """ + CategoriesOverride. + + :param str category: (optional) The category tag name to override. + :param bool enabled: (optional) + :param str action: (optional) What happens when theres a match for the rule + expression. + """ + + def __init__( + self, + *, + category: Optional[str] = None, + enabled: Optional[bool] = None, + action: Optional[str] = None, + ) -> None: + """ + Initialize a CategoriesOverride object. + + :param str category: (optional) The category tag name to override. + :param bool enabled: (optional) + :param str action: (optional) What happens when theres a match for the rule + expression. + """ + self.category = category + self.enabled = enabled + self.action = action + + @classmethod + def from_dict(cls, _dict: Dict) -> 'CategoriesOverride': + """Initialize a CategoriesOverride object from a json dictionary.""" + args = {} + category = _dict.get('category') + if category is not None: + args['category'] = category + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + action = _dict.get('action') + if action is not None: + args['action'] = action + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a CategoriesOverride object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'category') and self.category is not None: + _dict['category'] = self.category + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + if hasattr(self, 'action') and self.action is not None: + _dict['action'] = self.action + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this CategoriesOverride object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'CategoriesOverride') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'CategoriesOverride') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class ListRulesetsResp: + """ + List rulesets response. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param List[ListedRuleset] result: Container for response information. + """ + + def __init__( + self, + success: bool, + errors: List['Message'], + messages: List['Message'], + result: List['ListedRuleset'], + ) -> None: + """ + Initialize a ListRulesetsResp object. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param List[ListedRuleset] result: Container for response information. + """ + self.success = success + self.errors = errors + self.messages = messages + self.result = result + + @classmethod + def from_dict(cls, _dict: Dict) -> 'ListRulesetsResp': + """Initialize a ListRulesetsResp object from a json dictionary.""" + args = {} + success = _dict.get('success') + if success is not None: + args['success'] = success + else: + raise ValueError('Required property \'success\' not present in ListRulesetsResp JSON') + errors = _dict.get('errors') + if errors is not None: + args['errors'] = [Message.from_dict(v) for v in errors] + else: + raise ValueError('Required property \'errors\' not present in ListRulesetsResp JSON') + messages = _dict.get('messages') + if messages is not None: + args['messages'] = [Message.from_dict(v) for v in messages] + else: + raise ValueError('Required property \'messages\' not present in ListRulesetsResp JSON') + result = _dict.get('result') + if result is not None: + args['result'] = [ListedRuleset.from_dict(v) for v in result] + else: + raise ValueError('Required property \'result\' not present in ListRulesetsResp JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a ListRulesetsResp object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'success') and self.success is not None: + _dict['success'] = self.success + if hasattr(self, 'errors') and self.errors is not None: + errors_list = [] + for v in self.errors: + if isinstance(v, dict): + errors_list.append(v) + else: + errors_list.append(v.to_dict()) + _dict['errors'] = errors_list + if hasattr(self, 'messages') and self.messages is not None: + messages_list = [] + for v in self.messages: + if isinstance(v, dict): + messages_list.append(v) + else: + messages_list.append(v.to_dict()) + _dict['messages'] = messages_list + if hasattr(self, 'result') and self.result is not None: + result_list = [] + for v in self.result: + if isinstance(v, dict): + result_list.append(v) + else: + result_list.append(v.to_dict()) + _dict['result'] = result_list + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this ListRulesetsResp object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'ListRulesetsResp') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'ListRulesetsResp') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class ListedRuleset: + """ + ListedRuleset. + + :param str description: description of the ruleset. + :param str id: unique ID of the ruleset. + :param str kind: + :param str last_updated: The timestamp of when the resource was last modified. + :param str name: human readable name of the ruleset. + :param str phase: The phase of the ruleset. + :param str version: The version of the ruleset. + """ + + def __init__( + self, + description: str, + id: str, + kind: str, + last_updated: str, + name: str, + phase: str, + version: str, + ) -> None: + """ + Initialize a ListedRuleset object. + + :param str description: description of the ruleset. + :param str id: unique ID of the ruleset. + :param str kind: + :param str last_updated: The timestamp of when the resource was last + modified. + :param str name: human readable name of the ruleset. + :param str phase: The phase of the ruleset. + :param str version: The version of the ruleset. + """ + self.description = description + self.id = id + self.kind = kind + self.last_updated = last_updated + self.name = name + self.phase = phase + self.version = version + + @classmethod + def from_dict(cls, _dict: Dict) -> 'ListedRuleset': + """Initialize a ListedRuleset object from a json dictionary.""" + args = {} + description = _dict.get('description') + if description is not None: + args['description'] = description + else: + raise ValueError('Required property \'description\' not present in ListedRuleset JSON') + id = _dict.get('id') + if id is not None: + args['id'] = id + else: + raise ValueError('Required property \'id\' not present in ListedRuleset JSON') + kind = _dict.get('kind') + if kind is not None: + args['kind'] = kind + else: + raise ValueError('Required property \'kind\' not present in ListedRuleset JSON') + last_updated = _dict.get('last_updated') + if last_updated is not None: + args['last_updated'] = last_updated + else: + raise ValueError('Required property \'last_updated\' not present in ListedRuleset JSON') + name = _dict.get('name') + if name is not None: + args['name'] = name + else: + raise ValueError('Required property \'name\' not present in ListedRuleset JSON') + phase = _dict.get('phase') + if phase is not None: + args['phase'] = phase + else: + raise ValueError('Required property \'phase\' not present in ListedRuleset JSON') + version = _dict.get('version') + if version is not None: + args['version'] = version + else: + raise ValueError('Required property \'version\' not present in ListedRuleset JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a ListedRuleset object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'description') and self.description is not None: + _dict['description'] = self.description + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'kind') and self.kind is not None: + _dict['kind'] = self.kind + if hasattr(self, 'last_updated') and self.last_updated is not None: + _dict['last_updated'] = self.last_updated + if hasattr(self, 'name') and self.name is not None: + _dict['name'] = self.name + if hasattr(self, 'phase') and self.phase is not None: + _dict['phase'] = self.phase + if hasattr(self, 'version') and self.version is not None: + _dict['version'] = self.version + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this ListedRuleset object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'ListedRuleset') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'ListedRuleset') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + class KindEnum(str, Enum): + """ + kind. + """ + + MANAGED = 'managed' + CUSTOM = 'custom' + ROOT = 'root' + ZONE = 'zone' + + + class PhaseEnum(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + + +class Logging: + """ + Logging. + + :param bool enabled: + """ + + def __init__( + self, + enabled: bool, + ) -> None: + """ + Initialize a Logging object. + + :param bool enabled: + """ + self.enabled = enabled + + @classmethod + def from_dict(cls, _dict: Dict) -> 'Logging': + """Initialize a Logging object from a json dictionary.""" + args = {} + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + else: + raise ValueError('Required property \'enabled\' not present in Logging JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a Logging object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this Logging object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'Logging') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'Logging') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class Message: + """ + Message. + + :param int code: (optional) A unique code for this message. + :param str message: A text description of this message. + :param MessageSource source: (optional) The source of this message. + """ + + def __init__( + self, + message: str, + *, + code: Optional[int] = None, + source: Optional['MessageSource'] = None, + ) -> None: + """ + Initialize a Message object. + + :param str message: A text description of this message. + :param int code: (optional) A unique code for this message. + :param MessageSource source: (optional) The source of this message. + """ + self.code = code + self.message = message + self.source = source + + @classmethod + def from_dict(cls, _dict: Dict) -> 'Message': + """Initialize a Message object from a json dictionary.""" + args = {} + code = _dict.get('code') + if code is not None: + args['code'] = code + message = _dict.get('message') + if message is not None: + args['message'] = message + else: + raise ValueError('Required property \'message\' not present in Message JSON') + source = _dict.get('source') + if source is not None: + args['source'] = MessageSource.from_dict(source) + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a Message object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'code') and self.code is not None: + _dict['code'] = self.code + if hasattr(self, 'message') and self.message is not None: + _dict['message'] = self.message + if hasattr(self, 'source') and self.source is not None: + if isinstance(self.source, dict): + _dict['source'] = self.source + else: + _dict['source'] = self.source.to_dict() + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this Message object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'Message') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'Message') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class Overrides: + """ + Overrides. + + :param str action: (optional) What happens when theres a match for the rule + expression. + :param bool enabled: (optional) + :param str sensitivity_level: (optional) The sensitivity level of the rule. + :param List[RulesOverride] rules: (optional) + :param List[CategoriesOverride] categories: (optional) + """ + + def __init__( + self, + *, + action: Optional[str] = None, + enabled: Optional[bool] = None, + sensitivity_level: Optional[str] = None, + rules: Optional[List['RulesOverride']] = None, + categories: Optional[List['CategoriesOverride']] = None, + ) -> None: + """ + Initialize a Overrides object. + + :param str action: (optional) What happens when theres a match for the rule + expression. + :param bool enabled: (optional) + :param str sensitivity_level: (optional) The sensitivity level of the rule. + :param List[RulesOverride] rules: (optional) + :param List[CategoriesOverride] categories: (optional) + """ + self.action = action + self.enabled = enabled + self.sensitivity_level = sensitivity_level + self.rules = rules + self.categories = categories + + @classmethod + def from_dict(cls, _dict: Dict) -> 'Overrides': + """Initialize a Overrides object from a json dictionary.""" + args = {} + action = _dict.get('action') + if action is not None: + args['action'] = action + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + sensitivity_level = _dict.get('sensitivity_level') + if sensitivity_level is not None: + args['sensitivity_level'] = sensitivity_level + rules = _dict.get('rules') + if rules is not None: + args['rules'] = [RulesOverride.from_dict(v) for v in rules] + categories = _dict.get('categories') + if categories is not None: + args['categories'] = [CategoriesOverride.from_dict(v) for v in categories] + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a Overrides object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'action') and self.action is not None: + _dict['action'] = self.action + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + if hasattr(self, 'sensitivity_level') and self.sensitivity_level is not None: + _dict['sensitivity_level'] = self.sensitivity_level + if hasattr(self, 'rules') and self.rules is not None: + rules_list = [] + for v in self.rules: + if isinstance(v, dict): + rules_list.append(v) + else: + rules_list.append(v.to_dict()) + _dict['rules'] = rules_list + if hasattr(self, 'categories') and self.categories is not None: + categories_list = [] + for v in self.categories: + if isinstance(v, dict): + categories_list.append(v) + else: + categories_list.append(v.to_dict()) + _dict['categories'] = categories_list + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this Overrides object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'Overrides') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'Overrides') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + class SensitivityLevelEnum(str, Enum): + """ + The sensitivity level of the rule. + """ + + HIGH = 'high' + MEDIUM = 'medium' + LOW = 'low' + + + +class Position: + """ + Position. + + :param str before: (optional) The rule ID to place this rule before. + :param str after: (optional) The rule ID to place this rule after. + :param int index: (optional) The index to place this rule at. + """ + + def __init__( + self, + *, + before: Optional[str] = None, + after: Optional[str] = None, + index: Optional[int] = None, + ) -> None: + """ + Initialize a Position object. + + :param str before: (optional) The rule ID to place this rule before. + :param str after: (optional) The rule ID to place this rule after. + :param int index: (optional) The index to place this rule at. + """ + self.before = before + self.after = after + self.index = index + + @classmethod + def from_dict(cls, _dict: Dict) -> 'Position': + """Initialize a Position object from a json dictionary.""" + args = {} + before = _dict.get('before') + if before is not None: + args['before'] = before + after = _dict.get('after') + if after is not None: + args['after'] = after + index = _dict.get('index') + if index is not None: + args['index'] = index + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a Position object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'before') and self.before is not None: + _dict['before'] = self.before + if hasattr(self, 'after') and self.after is not None: + _dict['after'] = self.after + if hasattr(self, 'index') and self.index is not None: + _dict['index'] = self.index + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this Position object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'Position') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'Position') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class Ratelimit: + """ + Ratelimit. + + :param List[str] characteristics: (optional) The set of parameters that define + how rate for this rule is tracked. + :param str counting_expression: (optional) Expression that specifies the + criteria you are matching traffic on. + :param int mitigation_timeout: (optional) Once the rate is reached, the rate + limiting rule blocks further requests for the period of time defined in this + field. + :param int period: (optional) The period of time to consider (in seconds) when + evaluating the rate. + :param int requests_per_period: (optional) The number of requests over the + period of time that will trigger the rate limiting rule. + """ + + def __init__( + self, + *, + characteristics: Optional[List[str]] = None, + counting_expression: Optional[str] = None, + mitigation_timeout: Optional[int] = None, + period: Optional[int] = None, + requests_per_period: Optional[int] = None, + ) -> None: + """ + Initialize a Ratelimit object. + + :param List[str] characteristics: (optional) The set of parameters that + define how rate for this rule is tracked. + :param str counting_expression: (optional) Expression that specifies the + criteria you are matching traffic on. + :param int mitigation_timeout: (optional) Once the rate is reached, the + rate limiting rule blocks further requests for the period of time defined + in this field. + :param int period: (optional) The period of time to consider (in seconds) + when evaluating the rate. + :param int requests_per_period: (optional) The number of requests over the + period of time that will trigger the rate limiting rule. + """ + self.characteristics = characteristics + self.counting_expression = counting_expression + self.mitigation_timeout = mitigation_timeout + self.period = period + self.requests_per_period = requests_per_period + + @classmethod + def from_dict(cls, _dict: Dict) -> 'Ratelimit': + """Initialize a Ratelimit object from a json dictionary.""" + args = {} + characteristics = _dict.get('characteristics') + if characteristics is not None: + args['characteristics'] = characteristics + counting_expression = _dict.get('counting_expression') + if counting_expression is not None: + args['counting_expression'] = counting_expression + mitigation_timeout = _dict.get('mitigation_timeout') + if mitigation_timeout is not None: + args['mitigation_timeout'] = mitigation_timeout + period = _dict.get('period') + if period is not None: + args['period'] = period + requests_per_period = _dict.get('requests_per_period') + if requests_per_period is not None: + args['requests_per_period'] = requests_per_period + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a Ratelimit object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'characteristics') and self.characteristics is not None: + _dict['characteristics'] = self.characteristics + if hasattr(self, 'counting_expression') and self.counting_expression is not None: + _dict['counting_expression'] = self.counting_expression + if hasattr(self, 'mitigation_timeout') and self.mitigation_timeout is not None: + _dict['mitigation_timeout'] = self.mitigation_timeout + if hasattr(self, 'period') and self.period is not None: + _dict['period'] = self.period + if hasattr(self, 'requests_per_period') and self.requests_per_period is not None: + _dict['requests_per_period'] = self.requests_per_period + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this Ratelimit object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'Ratelimit') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'Ratelimit') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class RuleCreate: + """ + RuleCreate. + + :param str action: What happens when theres a match for the rule expression. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str expression: The expression defining which traffic will match the + rule. + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by default). + :param Position position: (optional) + """ + + def __init__( + self, + action: str, + expression: str, + *, + action_parameters: Optional['ActionParameters'] = None, + ratelimit: Optional['Ratelimit'] = None, + description: Optional[str] = None, + enabled: Optional[bool] = None, + id: Optional[str] = None, + logging: Optional['Logging'] = None, + ref: Optional[str] = None, + position: Optional['Position'] = None, + ) -> None: + """ + Initialize a RuleCreate object. + + :param str action: What happens when theres a match for the rule + expression. + :param str expression: The expression defining which traffic will match the + rule. + :param ActionParameters action_parameters: (optional) + :param Ratelimit ratelimit: (optional) + :param str description: (optional) + :param bool enabled: (optional) + :param str id: (optional) + :param Logging logging: (optional) + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Position position: (optional) + """ + self.action = action + self.action_parameters = action_parameters + self.ratelimit = ratelimit + self.description = description + self.enabled = enabled + self.expression = expression + self.id = id + self.logging = logging + self.ref = ref + self.position = position + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RuleCreate': + """Initialize a RuleCreate object from a json dictionary.""" + args = {} + action = _dict.get('action') + if action is not None: + args['action'] = action + else: + raise ValueError('Required property \'action\' not present in RuleCreate JSON') + action_parameters = _dict.get('action_parameters') + if action_parameters is not None: + args['action_parameters'] = ActionParameters.from_dict(action_parameters) + ratelimit = _dict.get('ratelimit') + if ratelimit is not None: + args['ratelimit'] = Ratelimit.from_dict(ratelimit) + description = _dict.get('description') + if description is not None: + args['description'] = description + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + expression = _dict.get('expression') + if expression is not None: + args['expression'] = expression + else: + raise ValueError('Required property \'expression\' not present in RuleCreate JSON') + id = _dict.get('id') + if id is not None: + args['id'] = id + logging = _dict.get('logging') + if logging is not None: + args['logging'] = Logging.from_dict(logging) + ref = _dict.get('ref') + if ref is not None: + args['ref'] = ref + position = _dict.get('position') + if position is not None: + args['position'] = Position.from_dict(position) + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RuleCreate object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'action') and self.action is not None: + _dict['action'] = self.action + if hasattr(self, 'action_parameters') and self.action_parameters is not None: + if isinstance(self.action_parameters, dict): + _dict['action_parameters'] = self.action_parameters + else: + _dict['action_parameters'] = self.action_parameters.to_dict() + if hasattr(self, 'ratelimit') and self.ratelimit is not None: + if isinstance(self.ratelimit, dict): + _dict['ratelimit'] = self.ratelimit + else: + _dict['ratelimit'] = self.ratelimit.to_dict() + if hasattr(self, 'description') and self.description is not None: + _dict['description'] = self.description + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + if hasattr(self, 'expression') and self.expression is not None: + _dict['expression'] = self.expression + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'logging') and self.logging is not None: + if isinstance(self.logging, dict): + _dict['logging'] = self.logging + else: + _dict['logging'] = self.logging.to_dict() + if hasattr(self, 'ref') and self.ref is not None: + _dict['ref'] = self.ref + if hasattr(self, 'position') and self.position is not None: + if isinstance(self.position, dict): + _dict['position'] = self.position + else: + _dict['position'] = self.position.to_dict() + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RuleCreate object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RuleCreate') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RuleCreate') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class RuleDetails: + """ + RuleDetails. + + :param str id: unique ID of rule. + :param str version: (optional) The version of the rule. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param ActionParameters action_parameters: (optional) + :param List[str] categories: (optional) List of categories for the rule. + :param bool enabled: (optional) Is the rule enabled. + :param str description: (optional) description of the rule. + :param str expression: (optional) The expression defining which traffic will + match the rule. + :param str ref: (optional) The reference of the rule (the rule ID by default). + :param Logging logging: (optional) + :param str last_updated: (optional) The timestamp of when the resource was last + modified. + """ + + def __init__( + self, + id: str, + *, + version: Optional[str] = None, + action: Optional[str] = None, + action_parameters: Optional['ActionParameters'] = None, + categories: Optional[List[str]] = None, + enabled: Optional[bool] = None, + description: Optional[str] = None, + expression: Optional[str] = None, + ref: Optional[str] = None, + logging: Optional['Logging'] = None, + last_updated: Optional[str] = None, + ) -> None: + """ + Initialize a RuleDetails object. + + :param str id: unique ID of rule. + :param str version: (optional) The version of the rule. + :param str action: (optional) What happens when theres a match for the rule + expression. + :param ActionParameters action_parameters: (optional) + :param List[str] categories: (optional) List of categories for the rule. + :param bool enabled: (optional) Is the rule enabled. + :param str description: (optional) description of the rule. + :param str expression: (optional) The expression defining which traffic + will match the rule. + :param str ref: (optional) The reference of the rule (the rule ID by + default). + :param Logging logging: (optional) + :param str last_updated: (optional) The timestamp of when the resource was + last modified. + """ + self.id = id + self.version = version + self.action = action + self.action_parameters = action_parameters + self.categories = categories + self.enabled = enabled + self.description = description + self.expression = expression + self.ref = ref + self.logging = logging + self.last_updated = last_updated + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RuleDetails': + """Initialize a RuleDetails object from a json dictionary.""" + args = {} + id = _dict.get('id') + if id is not None: + args['id'] = id + else: + raise ValueError('Required property \'id\' not present in RuleDetails JSON') + version = _dict.get('version') + if version is not None: + args['version'] = version + action = _dict.get('action') + if action is not None: + args['action'] = action + action_parameters = _dict.get('action_parameters') + if action_parameters is not None: + args['action_parameters'] = ActionParameters.from_dict(action_parameters) + categories = _dict.get('categories') + if categories is not None: + args['categories'] = categories + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + description = _dict.get('description') + if description is not None: + args['description'] = description + expression = _dict.get('expression') + if expression is not None: + args['expression'] = expression + ref = _dict.get('ref') + if ref is not None: + args['ref'] = ref + logging = _dict.get('logging') + if logging is not None: + args['logging'] = Logging.from_dict(logging) + last_updated = _dict.get('last_updated') + if last_updated is not None: + args['last_updated'] = last_updated + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RuleDetails object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'version') and self.version is not None: + _dict['version'] = self.version + if hasattr(self, 'action') and self.action is not None: + _dict['action'] = self.action + if hasattr(self, 'action_parameters') and self.action_parameters is not None: + if isinstance(self.action_parameters, dict): + _dict['action_parameters'] = self.action_parameters + else: + _dict['action_parameters'] = self.action_parameters.to_dict() + if hasattr(self, 'categories') and self.categories is not None: + _dict['categories'] = self.categories + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + if hasattr(self, 'description') and self.description is not None: + _dict['description'] = self.description + if hasattr(self, 'expression') and self.expression is not None: + _dict['expression'] = self.expression + if hasattr(self, 'ref') and self.ref is not None: + _dict['ref'] = self.ref + if hasattr(self, 'logging') and self.logging is not None: + if isinstance(self.logging, dict): + _dict['logging'] = self.logging + else: + _dict['logging'] = self.logging.to_dict() + if hasattr(self, 'last_updated') and self.last_updated is not None: + _dict['last_updated'] = self.last_updated + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RuleDetails object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RuleDetails') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RuleDetails') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class RuleResp: + """ + List rules response. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param RuleDetails result: + """ + + def __init__( + self, + success: bool, + errors: List['Message'], + messages: List['Message'], + result: 'RuleDetails', + ) -> None: + """ + Initialize a RuleResp object. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param RuleDetails result: + """ + self.success = success + self.errors = errors + self.messages = messages + self.result = result + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RuleResp': + """Initialize a RuleResp object from a json dictionary.""" + args = {} + success = _dict.get('success') + if success is not None: + args['success'] = success + else: + raise ValueError('Required property \'success\' not present in RuleResp JSON') + errors = _dict.get('errors') + if errors is not None: + args['errors'] = [Message.from_dict(v) for v in errors] + else: + raise ValueError('Required property \'errors\' not present in RuleResp JSON') + messages = _dict.get('messages') + if messages is not None: + args['messages'] = [Message.from_dict(v) for v in messages] + else: + raise ValueError('Required property \'messages\' not present in RuleResp JSON') + result = _dict.get('result') + if result is not None: + args['result'] = RuleDetails.from_dict(result) + else: + raise ValueError('Required property \'result\' not present in RuleResp JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RuleResp object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'success') and self.success is not None: + _dict['success'] = self.success + if hasattr(self, 'errors') and self.errors is not None: + errors_list = [] + for v in self.errors: + if isinstance(v, dict): + errors_list.append(v) + else: + errors_list.append(v.to_dict()) + _dict['errors'] = errors_list + if hasattr(self, 'messages') and self.messages is not None: + messages_list = [] + for v in self.messages: + if isinstance(v, dict): + messages_list.append(v) + else: + messages_list.append(v.to_dict()) + _dict['messages'] = messages_list + if hasattr(self, 'result') and self.result is not None: + if isinstance(self.result, dict): + _dict['result'] = self.result + else: + _dict['result'] = self.result.to_dict() + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RuleResp object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RuleResp') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RuleResp') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + +class RulesOverride: + """ + RulesOverride. + + :param str id: (optional) + :param bool enabled: (optional) + :param str action: (optional) What happens when theres a match for the rule + expression. + :param str sensitivity_level: (optional) The sensitivity level of the rule. + :param int score_threshold: (optional) The score threshold of the rule. + """ + + def __init__( + self, + *, + id: Optional[str] = None, + enabled: Optional[bool] = None, + action: Optional[str] = None, + sensitivity_level: Optional[str] = None, + score_threshold: Optional[int] = None, + ) -> None: + """ + Initialize a RulesOverride object. + + :param str id: (optional) + :param bool enabled: (optional) + :param str action: (optional) What happens when theres a match for the rule + expression. + :param str sensitivity_level: (optional) The sensitivity level of the rule. + :param int score_threshold: (optional) The score threshold of the rule. + """ + self.id = id + self.enabled = enabled + self.action = action + self.sensitivity_level = sensitivity_level + self.score_threshold = score_threshold + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RulesOverride': + """Initialize a RulesOverride object from a json dictionary.""" + args = {} + id = _dict.get('id') + if id is not None: + args['id'] = id + enabled = _dict.get('enabled') + if enabled is not None: + args['enabled'] = enabled + action = _dict.get('action') + if action is not None: + args['action'] = action + sensitivity_level = _dict.get('sensitivity_level') + if sensitivity_level is not None: + args['sensitivity_level'] = sensitivity_level + score_threshold = _dict.get('score_threshold') + if score_threshold is not None: + args['score_threshold'] = score_threshold + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RulesOverride object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'enabled') and self.enabled is not None: + _dict['enabled'] = self.enabled + if hasattr(self, 'action') and self.action is not None: + _dict['action'] = self.action + if hasattr(self, 'sensitivity_level') and self.sensitivity_level is not None: + _dict['sensitivity_level'] = self.sensitivity_level + if hasattr(self, 'score_threshold') and self.score_threshold is not None: + _dict['score_threshold'] = self.score_threshold + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RulesOverride object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RulesOverride') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RulesOverride') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + class SensitivityLevelEnum(str, Enum): + """ + The sensitivity level of the rule. + """ + + HIGH = 'high' + MEDIUM = 'medium' + LOW = 'low' + + + +class RulesetDetails: + """ + RulesetDetails. + + :param str description: description of the ruleset. + :param str id: unique ID of the ruleset. + :param str kind: + :param str last_updated: The timestamp of when the resource was last modified. + :param str name: human readable name of the ruleset. + :param str phase: The phase of the ruleset. + :param str version: The version of the ruleset. + :param List[RuleDetails] rules: + """ + + def __init__( + self, + description: str, + id: str, + kind: str, + last_updated: str, + name: str, + phase: str, + version: str, + rules: List['RuleDetails'], + ) -> None: + """ + Initialize a RulesetDetails object. + + :param str description: description of the ruleset. + :param str id: unique ID of the ruleset. + :param str kind: + :param str last_updated: The timestamp of when the resource was last + modified. + :param str name: human readable name of the ruleset. + :param str phase: The phase of the ruleset. + :param str version: The version of the ruleset. + :param List[RuleDetails] rules: + """ + self.description = description + self.id = id + self.kind = kind + self.last_updated = last_updated + self.name = name + self.phase = phase + self.version = version + self.rules = rules + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RulesetDetails': + """Initialize a RulesetDetails object from a json dictionary.""" + args = {} + description = _dict.get('description') + if description is not None: + args['description'] = description + else: + raise ValueError('Required property \'description\' not present in RulesetDetails JSON') + id = _dict.get('id') + if id is not None: + args['id'] = id + else: + raise ValueError('Required property \'id\' not present in RulesetDetails JSON') + kind = _dict.get('kind') + if kind is not None: + args['kind'] = kind + else: + raise ValueError('Required property \'kind\' not present in RulesetDetails JSON') + last_updated = _dict.get('last_updated') + if last_updated is not None: + args['last_updated'] = last_updated + else: + raise ValueError('Required property \'last_updated\' not present in RulesetDetails JSON') + name = _dict.get('name') + if name is not None: + args['name'] = name + else: + raise ValueError('Required property \'name\' not present in RulesetDetails JSON') + phase = _dict.get('phase') + if phase is not None: + args['phase'] = phase + else: + raise ValueError('Required property \'phase\' not present in RulesetDetails JSON') + version = _dict.get('version') + if version is not None: + args['version'] = version + else: + raise ValueError('Required property \'version\' not present in RulesetDetails JSON') + rules = _dict.get('rules') + if rules is not None: + args['rules'] = [RuleDetails.from_dict(v) for v in rules] + else: + raise ValueError('Required property \'rules\' not present in RulesetDetails JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RulesetDetails object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'description') and self.description is not None: + _dict['description'] = self.description + if hasattr(self, 'id') and self.id is not None: + _dict['id'] = self.id + if hasattr(self, 'kind') and self.kind is not None: + _dict['kind'] = self.kind + if hasattr(self, 'last_updated') and self.last_updated is not None: + _dict['last_updated'] = self.last_updated + if hasattr(self, 'name') and self.name is not None: + _dict['name'] = self.name + if hasattr(self, 'phase') and self.phase is not None: + _dict['phase'] = self.phase + if hasattr(self, 'version') and self.version is not None: + _dict['version'] = self.version + if hasattr(self, 'rules') and self.rules is not None: + rules_list = [] + for v in self.rules: + if isinstance(v, dict): + rules_list.append(v) + else: + rules_list.append(v.to_dict()) + _dict['rules'] = rules_list + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RulesetDetails object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RulesetDetails') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RulesetDetails') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other + + class KindEnum(str, Enum): + """ + kind. + """ + + MANAGED = 'managed' + CUSTOM = 'custom' + ROOT = 'root' + ZONE = 'zone' + + + class PhaseEnum(str, Enum): + """ + The phase of the ruleset. + """ + + DDOS_L4 = 'ddos_l4' + DDOS_L7 = 'ddos_l7' + HTTP_CONFIG_SETTINGS = 'http_config_settings' + HTTP_CUSTOM_ERRORS = 'http_custom_errors' + HTTP_LOG_CUSTOM_FIELDS = 'http_log_custom_fields' + HTTP_RATELIMIT = 'http_ratelimit' + HTTP_REQUEST_CACHE_SETTINGS = 'http_request_cache_settings' + HTTP_REQUEST_DYNAMIC_REDIRECT = 'http_request_dynamic_redirect' + HTTP_REQUEST_FIREWALL_CUSTOM = 'http_request_firewall_custom' + HTTP_REQUEST_FIREWALL_MANAGED = 'http_request_firewall_managed' + HTTP_REQUEST_LATE_TRANSFORM = 'http_request_late_transform' + HTTP_REQUEST_ORIGIN = 'http_request_origin' + HTTP_REQUEST_REDIRECT = 'http_request_redirect' + HTTP_REQUEST_SANITIZE = 'http_request_sanitize' + HTTP_REQUEST_SBFM = 'http_request_sbfm' + HTTP_REQUEST_SELECT_CONFIGURATION = 'http_request_select_configuration' + HTTP_REQUEST_TRANSFORM = 'http_request_transform' + HTTP_RESPONSE_COMPRESSION = 'http_response_compression' + HTTP_RESPONSE_FIREWALL_MANAGED = 'http_response_firewall_managed' + HTTP_RESPONSE_HEADERS_TRANSFORM = 'http_response_headers_transform' + + + +class RulesetResp: + """ + Ruleset response. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param RulesetDetails result: + """ + + def __init__( + self, + success: bool, + errors: List['Message'], + messages: List['Message'], + result: 'RulesetDetails', + ) -> None: + """ + Initialize a RulesetResp object. + + :param bool success: Was operation successful. + :param List[Message] errors: Array of errors encountered. + :param List[Message] messages: Array of messages returned. + :param RulesetDetails result: + """ + self.success = success + self.errors = errors + self.messages = messages + self.result = result + + @classmethod + def from_dict(cls, _dict: Dict) -> 'RulesetResp': + """Initialize a RulesetResp object from a json dictionary.""" + args = {} + success = _dict.get('success') + if success is not None: + args['success'] = success + else: + raise ValueError('Required property \'success\' not present in RulesetResp JSON') + errors = _dict.get('errors') + if errors is not None: + args['errors'] = [Message.from_dict(v) for v in errors] + else: + raise ValueError('Required property \'errors\' not present in RulesetResp JSON') + messages = _dict.get('messages') + if messages is not None: + args['messages'] = [Message.from_dict(v) for v in messages] + else: + raise ValueError('Required property \'messages\' not present in RulesetResp JSON') + result = _dict.get('result') + if result is not None: + args['result'] = RulesetDetails.from_dict(result) + else: + raise ValueError('Required property \'result\' not present in RulesetResp JSON') + return cls(**args) + + @classmethod + def _from_dict(cls, _dict): + """Initialize a RulesetResp object from a json dictionary.""" + return cls.from_dict(_dict) + + def to_dict(self) -> Dict: + """Return a json dictionary representing this model.""" + _dict = {} + if hasattr(self, 'success') and self.success is not None: + _dict['success'] = self.success + if hasattr(self, 'errors') and self.errors is not None: + errors_list = [] + for v in self.errors: + if isinstance(v, dict): + errors_list.append(v) + else: + errors_list.append(v.to_dict()) + _dict['errors'] = errors_list + if hasattr(self, 'messages') and self.messages is not None: + messages_list = [] + for v in self.messages: + if isinstance(v, dict): + messages_list.append(v) + else: + messages_list.append(v.to_dict()) + _dict['messages'] = messages_list + if hasattr(self, 'result') and self.result is not None: + if isinstance(self.result, dict): + _dict['result'] = self.result + else: + _dict['result'] = self.result.to_dict() + return _dict + + def _to_dict(self): + """Return a json dictionary representing this model.""" + return self.to_dict() + + def __str__(self) -> str: + """Return a `str` version of this RulesetResp object.""" + return json.dumps(self.to_dict(), indent=2) + + def __eq__(self, other: 'RulesetResp') -> bool: + """Return `true` when self and other are equal, false otherwise.""" + if not isinstance(other, self.__class__): + return False + return self.__dict__ == other.__dict__ + + def __ne__(self, other: 'RulesetResp') -> bool: + """Return `true` when self and other are not equal, false otherwise.""" + return not self == other \ No newline at end of file diff --git a/test/integration/test_rulesets_v1.py b/test/integration/test_rulesets_v1.py new file mode 100644 index 0000000..99a5b5c --- /dev/null +++ b/test/integration/test_rulesets_v1.py @@ -0,0 +1,926 @@ +# -*- coding: utf-8 -*- +# (C) Copyright IBM Corp. 2025. + +""" +Integration test code for RulesetsV1 +""" + +import os +import unittest +from dotenv import load_dotenv, find_dotenv +from ibm_cloud_sdk_core.authenticators import IAMAuthenticator +from ibm_cloud_networking_services.rulesets_v1 import ( + RulesetsV1, + RulesOverride, + CategoriesOverride, + Overrides, + ActionParameters, + Position, + RuleCreate, + Ratelimit +) + +configFile = "cis.env" + +# load the .env file containing your environment variables +try: + load_dotenv(find_dotenv(filename="cis.env")) +except: + print('warning: no cis.env file loaded') + + +class TestInstanceRulesetsIntegration(unittest.TestCase): + """Instance Rulesets API integration test""" + + @classmethod + def setUpClass(cls): + if not os.path.exists(configFile): + raise unittest.SkipTest("External configuration not available, skipping...") + + api_key = os.getenv("CIS_SERVICES_APIKEY") + auth_url = os.getenv("CIS_SERVICES_AUTH_URL") + crn = os.getenv("CRN") + zone_id = os.getenv("ZONE_ID") + service_url = os.getenv("API_ENDPOINT") + + if not all([api_key, crn, zone_id]): + raise unittest.SkipTest("Environment variables not set properly") + + authenticator = IAMAuthenticator(api_key, url=auth_url) + cls.rulesets_service = RulesetsV1( + authenticator=authenticator, + crn=crn, + zone_identifier=zone_id + ) + if service_url: + cls.rulesets_service.set_service_url(service_url) + + cls.ruleset_to_deploy_id = None + cls.rule1_id = None + cls.rule2_id = None + cls.ruleset_for_testing_id = None + + cls.rulesets_service.enable_retries(max_retries=4, retry_interval=30) + + try: + cls.rulesets_service.get_instance_rulesets() + except Exception as e: + raise unittest.SkipTest(f"Authentication failed: {e}") + + def test_01_list_and_get_instance_ruleset(self): + list_resp = self.rulesets_service.get_instance_rulesets().get_result() + self.assertIn("result", list_resp) + self.assertGreater(len(list_resp["result"]), 0) + + self.__class__.ruleset_to_deploy_id = list_resp["result"][0]["id"] + + get_resp = self.rulesets_service.get_instance_ruleset( + ruleset_id=self.ruleset_to_deploy_id + ).get_result() + self.assertIn("result", get_resp) + self.assertIn("rules", get_resp["result"]) + self.assertGreaterEqual(len(get_resp["result"]["rules"]), 2) + + self.__class__.rule1_id = get_resp["result"]["rules"][0]["id"] + self.__class__.rule2_id = get_resp["result"]["rules"][1]["id"] + + def test_02_update_instance_entrypoint_ruleset(self): + rule_override = RulesOverride( + id=self.rule1_id, + enabled=True, + action="block", + score_threshold=60 + ) + + category_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="log" + ) + + overrides = Overrides( + action="log", + enabled=True, + rules=[rule_override], + categories=[category_override] + ) + + action_params = ActionParameters( + id=self.ruleset_to_deploy_id, + overrides=overrides + ) + + position = Position(index=1) + + rule_create = RuleCreate( + action="execute", + action_parameters=action_params, + description="Overriding rule", + enabled=True, + expression='(ip.src ne 1.1.1.1) and cf.zone.plan eq "ENT"', + ref=self.ruleset_to_deploy_id, + position=position + ) + + update_resp = self.rulesets_service.update_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed", + description="creating/updating entrypoint ruleset", + rules=[rule_create] + ).get_result() + + self.assertIn("result", update_resp) + rules = update_resp["result"].get("rules", []) + self.assertGreater(len(rules), 0) + self.assertEqual( + rules[0]["action_parameters"]["overrides"]["rules"][0]["score_threshold"], 60 + ) + + self.__class__.ruleset_for_testing_id = update_resp["result"]["id"] + + def test_03_update_instance_ruleset(self): + resp = self.rulesets_service.get_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ).get_result() + ruleset2update_id = resp["result"]["id"] + + rule_override = RulesOverride( + id=self.rule1_id, + enabled=True, + action="block" + ) + + category_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="block" + ) + + overrides = Overrides( + action="block", + enabled=True, + rules=[rule_override], + categories=[category_override] + ) + + action_params = ActionParameters( + id=self.ruleset_to_deploy_id, + overrides=overrides + ) + + position = Position(index=1) + + rule_create = RuleCreate( + action="execute", + action_parameters=action_params, + description="update rules", + enabled=True, + expression='(ip.src ne 1.1.1.2) and cf.zone.plan eq "ENT"', + ref=self.ruleset_to_deploy_id, + position=position + ) + + update_resp = self.rulesets_service.update_instance_ruleset( + ruleset_id=ruleset2update_id, + description="updating Instance ruleset", + rules=[rule_create] + ).get_result() + + self.assertIn("result", update_resp) + self.assertEqual(update_resp["result"]["id"], ruleset2update_id) + self.assertGreater(len(update_resp["result"]["rules"]), 0) + + def test_04_get_instance_entrypoint_ruleset(self): + resp = self.rulesets_service.get_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ) + self.assertEqual(resp.get_status_code(), 200) + result = resp.get_result() + self.assertIsNotNone(result) + self.assertIn("result", result) + + def test_05_list_and_get_instance_entrypoint_ruleset_version(self): + list_resp = self.rulesets_service.get_instance_entry_point_ruleset_versions( + ruleset_phase="http_request_firewall_managed" + ) + self.assertEqual(list_resp.get_status_code(), 200) + list_result = list_resp.get_result() + self.assertIsNotNone(list_result) + self.assertIn("result", list_result) + self.assertGreater(len(list_result["result"]), 1, "Need at least two versions for test") + + version = list_result["result"][1]["version"] + + get_version_resp = self.rulesets_service.get_instance_entry_point_ruleset_version( + ruleset_phase="http_request_firewall_managed", + ruleset_version=version + ) + self.assertEqual(get_version_resp.get_status_code(), 200) + version_result = get_version_resp.get_result() + self.assertIsNotNone(version_result) + self.assertIn("result", version_result) + + def test_06_list_get_delete_instance_ruleset_version(self): + ruleset_id = self.ruleset_for_testing_id + self.assertIsNotNone(ruleset_id, "ruleset_for_testing_id is None, cannot test versions") + + list_resp = self.rulesets_service.get_instance_ruleset_versions( + ruleset_id=ruleset_id + ).get_result() + + self.assertIsNotNone(list_resp) + self.assertIn("result", list_resp) + self.assertGreater(len(list_resp["result"]), 1, "Need at least two versions to test deletion") + + versions_sorted = sorted(list_resp["result"], key=lambda v: v["version"]) + latest_version = versions_sorted[-1]["version"] + version_to_delete = None + for v in reversed(versions_sorted[:-1]): + if v["version"] != latest_version: + version_to_delete = v["version"] + break + + self.assertIsNotNone(version_to_delete, "No deletable version found") + + get_resp = self.rulesets_service.get_instance_ruleset_version( + ruleset_id=ruleset_id, + ruleset_version=version_to_delete + ).get_result() + self.assertIsNotNone(get_resp) + + delete_resp = self.rulesets_service.delete_instance_ruleset_version( + ruleset_id=ruleset_id, + ruleset_version=version_to_delete + ) + self.assertEqual(delete_resp.get_status_code(), 204) + + def test_07_create_instance_ruleset_rule(self): + + resp = self.rulesets_service.get_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ).get_result() + ruleset2update_id = resp["result"]["id"] + + rule_override = RulesOverride( + id=self.rule2_id, + enabled=True, + action="log" + ) + + category_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="log" + ) + + overrides = Overrides( + enabled=False, + rules=[rule_override], + categories=[category_override] + ) + + action_params = ActionParameters( + id=self.ruleset_to_deploy_id, + overrides=overrides + ) + + position = Position(index=1) + + create_resp = self.rulesets_service.create_instance_ruleset_rule( + ruleset_id=ruleset2update_id, + action="execute", + action_parameters=action_params, + description="adding a rule to execute managed rules", + enabled=True, + expression='(ip.src ne 1.1.1.1) and cf.zone.plan eq "ENT"', + ref=ruleset2update_id, + position=position + ).get_result() + + self.assertIsNotNone(create_resp) + self.assertIn("id", create_resp["result"]) + + def test_08_create_instance_ruleset_rule_new(self): + from ibm_cloud_networking_services.rulesets_v1 import ( + RulesOverride, CategoriesOverride, Overrides, + ActionParameters, Position + ) + + resp = self.rulesets_service.get_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ).get_result() + ruleset2update_id = resp["result"]["id"] + + rule_override = RulesOverride( + id=self.rule2_id, + enabled=True, + action="log" + ) + + category_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="log" + ) + + overrides = Overrides( + enabled=False, + rules=[rule_override], + categories=[category_override] + ) + + action_params = ActionParameters( + id=self.ruleset_to_deploy_id, + overrides=overrides + ) + + position = Position(index=1) + + create_resp = self.rulesets_service.create_instance_ruleset_rule( + ruleset_id=ruleset2update_id, + action="execute", + action_parameters=action_params, + description="adding a rule to execute managed rules", + enabled=True, + expression='(ip.src ne 1.1.1.1) and cf.zone.plan eq "ENT"', + position=position + ) + + self.assertIsNotNone(create_resp) + self.assertIn("id", create_resp.get_result()["result"]) + + def test_09_update_delete_instance_ruleset_rule(self): + from ibm_cloud_networking_services.rulesets_v1 import ( + RulesOverride, CategoriesOverride, Overrides, + ActionParameters + ) + + resp = self.rulesets_service.get_instance_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ).get_result() + ruleset2update_id = resp["result"]["id"] + rule2update_id = resp["result"]["rules"][0]["id"] + + rule_override = RulesOverride( + id=self.rule2_id, + enabled=True, + action="block" + ) + + category_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="block" + ) + + overrides = Overrides( + action="block", + enabled=True, + rules=[rule_override], + categories=[category_override] + ) + + action_params = ActionParameters( + id=self.ruleset_to_deploy_id, + overrides=overrides + ) + + update_resp = self.rulesets_service.update_instance_ruleset_rule( + ruleset_id=ruleset2update_id, + rule_id=rule2update_id, + action="execute", + action_parameters=action_params, + description="editting rule", + enabled=True, + expression='(ip.src ne 1.1.1.3) and cf.zone.plan eq "ENT"' + ) + + self.assertEqual(update_resp.get_status_code(), 200) + update_result = update_resp.get_result() + self.assertIsNotNone(update_result) + + delete_resp = self.rulesets_service.delete_instance_ruleset_rule( + ruleset_id=ruleset2update_id, + rule_id=rule2update_id + ) + self.assertEqual(delete_resp.get_status_code(), 200) + delete_result = delete_resp.get_result() + self.assertIsNotNone(delete_result) + + def test_10_delete_instance_ruleset(self): + ruleset_id = self.ruleset_for_testing_id + self.assertIsNotNone(ruleset_id, "ruleset_for_testing_id is None, cannot delete") + + response = self.rulesets_service.delete_instance_ruleset( + ruleset_id=ruleset_id + ) + + self.assertEqual(response.get_status_code(), 204) + + def test_11_get_instance_ruleset_version_by_tag(self): + ruleset_id = self.ruleset_to_deploy_id + self.assertIsNotNone(ruleset_id, "ruleset_to_deploy_id is None, cannot get version by tag") + + rule_tag = "wordpress" + + versions_resp = self.rulesets_service.get_instance_ruleset_versions( + ruleset_id=ruleset_id + ).get_result() + + versions = [v["version"] for v in versions_resp["result"]] + self.assertTrue(len(versions) > 0, "No versions found for ruleset") + + ruleset_version = str(max(versions)) + + resp = self.rulesets_service.get_instance_ruleset_version_by_tag( + ruleset_id=ruleset_id, + ruleset_version=ruleset_version, + rule_tag=rule_tag + ) + + self.assertEqual(resp.get_status_code(), 200) + result = resp.get_result() + self.assertIsNotNone(result) + + @classmethod + def tearDownClass(cls): + if getattr(cls, "instance_ruleset_for_testing_id", None): + try: + resp = cls.rulesets_service.delete_instance_ruleset(cls.instance_ruleset_for_testing_id) + logger.info(f"Deleted instance ruleset {cls.instance_ruleset_for_testing_id}, status: {resp.get_status_code()}") + except Exception as e: + logger.warning(f"Failed to delete instance ruleset: {e}") + cls.instance_ruleset_for_testing_id = None + + if getattr(cls, "zone_ruleset_for_testing_id", None): + try: + resp = cls.rulesets_service.delete_zone_ruleset(cls.zone_ruleset_for_testing_id) + logger.info(f"Deleted zone ruleset {cls.zone_ruleset_for_testing_id}, status: {resp.get_status_code()}") + except Exception as e: + logger.warning(f"Failed to delete zone ruleset: {e}") + cls.zone_ruleset_for_testing_id = None + + +class TestZoneRulesets(unittest.TestCase): + """Zone Rulesets API integration test""" + + @classmethod + def setUpClass(cls): + cls.zone_ruleset_to_deploy = None + cls.zone_ruleset_to_deploy2 = None + cls.rule1_id = None + cls.rule2_id = None + cls.ruleset_for_testing_id = None + cls.ruleset_ep_ratelimit_testing_id = None + + api_key = os.getenv("CIS_SERVICES_APIKEY") + auth_url = os.getenv("CIS_SERVICES_AUTH_URL") + crn = os.getenv("CRN") + zone_id = os.getenv("ZONE_ID") + service_url = os.getenv("API_ENDPOINT") + + if not all([api_key, crn, zone_id]): + raise unittest.SkipTest("Environment variables not set properly") + + authenticator = IAMAuthenticator(api_key, url=auth_url) + cls.rulesets_service = RulesetsV1( + authenticator=authenticator, + crn=crn, + zone_identifier=zone_id + ) + if service_url: + cls.rulesets_service.set_service_url(service_url) + + cls.rulesets_service.enable_retries(max_retries=4, retry_interval=30) + + + response = cls.rulesets_service.get_zone_rulesets() + rulesets = response.get_result()['result'] + + for ruleset in rulesets: + if "CIS Managed Ruleset" in ruleset['name']: + cls.zone_ruleset_to_deploy = ruleset['id'] + if "CIS Managed Free Ruleset" in ruleset['name']: + cls.zone_ruleset_to_deploy2 = ruleset['id'] + + + response = cls.rulesets_service.get_zone_ruleset(cls.zone_ruleset_to_deploy) + rules = response.get_result().get('result', {}).get('rules', []) + cls.rule1_id = rules[0]['id'] + cls.rule2_id = rules[2]['id'] + + + response = cls.rulesets_service.update_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed", + description="temporary entrypoint ruleset for test" + ) + cls.ruleset_for_testing_id = response.get_result()['result']['id'] + + def test_list_get_zone_rulesets(self): + response = self.rulesets_service.get_zone_rulesets() + self.assertEqual(response.get_status_code(), 200) + rulesets = response.get_result()['result'] + + for ruleset in rulesets: + if "CIS Managed Ruleset" in ruleset['name']: + self.__class__.zone_ruleset_to_deploy = ruleset['id'] + if "CIS Managed Free Ruleset" in ruleset['name']: + self.__class__.zone_ruleset_to_deploy2 = ruleset['id'] + + + response = self.rulesets_service.get_zone_ruleset(self.zone_ruleset_to_deploy) + self.assertEqual(response.get_status_code(), 200) + rules = response.get_result().get('result', {}).get('rules', []) + self.__class__.rule1_id = rules[0]['id'] + self.__class__.rule2_id = rules[2]['id'] + + def test_update_zone_entrypoint_ruleset(self): + overrides = { + "action": "log", + "enabled": True, + "rules": [{ + "id": self.rule1_id, + "enabled": True, + "action": "log", + "score_threshold": 60 + }], + "categories": [{ + "category": "wordpress", + "enabled": True, + "action": "log" + }] + } + + action_params = {"id": self.zone_ruleset_to_deploy, "overrides": overrides} + + rule_create = { + "action": "execute", + "action_parameters": action_params, + "description": "overriding entrypoint ruleset rule", + "enabled": True, + "expression": "ip.src ne 1.1.1.1", + "position": {"index": 1} + } + + response = self.rulesets_service.update_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed", + description="updating entrypoint ruleset", + rules=[rule_create] + ) + self.assertEqual(response.get_status_code(), 200) + self.__class__.ruleset_for_testing_id = response.get_result()['result']['id'] + + def test_update_zone_entrypoint_ruleset_ratelimit(self): + + response = self.rulesets_service.update_zone_entrypoint_ruleset( + ruleset_phase="http_ratelimit", + description="updating entrypoint ruleset for ratelimit" + ) + + self.assertEqual(response.get_status_code(), 200) + self.__class__.ruleset_ep_ratelimit_testing_id = response.get_result()['result']['id'] + + def test_update_zone_ruleset(self): + rules_override = [{ + "id": self.rule1_id, + "enabled": True, + "action": "block" + }] + + categories_override = [{ + "category": "wordpress", + "enabled": True, + "action": "block" + }] + + overrides = { + "action": "block", + "enabled": True, + "rules": rules_override, + "categories": categories_override + } + + action_params = { + "id": self.zone_ruleset_to_deploy, + "overrides": overrides + } + + rule_create = { + "action": "execute", + "action_parameters": action_params, + "description": "deploying a managed rule", + "enabled": True, + "expression": "ip.src ne 1.1.1.2", + "ref": self.ruleset_for_testing_id, + "position": {"index": 1} + } + + response = self.rulesets_service.update_zone_ruleset( + ruleset_id=self.ruleset_for_testing_id, + description="Updating a zone ruleset", + rules=[rule_create] + ) + + self.assertEqual(response.get_status_code(), 200) + + def test_get_zone_entrypoint_ruleset(self): + from ibm_cloud_sdk_core import ApiException + + try: + response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ) + except ApiException as e: + if e.status_code == 404: + + resp = self.rulesets_service.update_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed", + description="temporary entrypoint ruleset for test" + ) + self.__class__.ruleset_for_testing_id = resp.get_result()['result']['id'] + + response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed" + ) + else: + raise + self.assertEqual(response.get_status_code(), 200) + self.assertIsNotNone(response.get_result()) + + def test_list_get_zone_entrypoint_ruleset_versions(self): + list_resp = self.rulesets_service.get_zone_entry_point_ruleset_versions( + ruleset_phase="http_request_firewall_managed" + ) + self.assertEqual(list_resp.get_status_code(), 200) + results = list_resp.get_result().get('result', []) + self.assertGreater(len(results), 0) + + + if len(results) > 1: + version = results[1]['version'] + else: + version = results[0]['version'] + + get_version_resp = self.rulesets_service.get_zone_entry_point_ruleset_version( + ruleset_phase="http_request_firewall_managed", + ruleset_version=version + ) + self.assertEqual(get_version_resp.get_status_code(), 200) + self.assertIsNotNone(get_version_resp.get_result()) + + def test_list_get_delete_zone_ruleset_version(self): + + list_resp = self.rulesets_service.get_zone_ruleset_versions( + ruleset_id=self.ruleset_for_testing_id + ) + self.assertEqual(list_resp.get_status_code(), 200) + versions = list_resp.get_result().get('result', []) + self.assertGreater(len(versions), 0) + + + if len(versions) > 1: + version_to_delete = versions[0]['version'] + else: + version_to_delete = None + + if version_to_delete: + + get_resp = self.rulesets_service.get_zone_ruleset_version( + ruleset_id=self.ruleset_for_testing_id, + ruleset_version=version_to_delete + ) + self.assertEqual(get_resp.get_status_code(), 200) + self.assertIsNotNone(get_resp.get_result()) + + + delete_resp = self.rulesets_service.delete_zone_ruleset_version( + ruleset_id=self.ruleset_for_testing_id, + ruleset_version=version_to_delete + ) + self.assertEqual(delete_resp.get_status_code(), 204) + else: + print("No older ruleset version to delete; skipping deletion.") + + def test_create_zone_ruleset_rule_execute(self): + + self.assertIsNotNone(self.ruleset_for_testing_id, "ruleset_for_testing_id is not set") + self.assertIsNotNone(self.zone_ruleset_to_deploy2, "zone_ruleset_to_deploy2 is not set") + + + response = self.rulesets_service.get_zone_ruleset(self.ruleset_for_testing_id) + rules = response.get_result().get('result', {}).get('rules', []) + + rule_id_to_use = rules[0]['id'] if rules else None + + + rules_override = RulesOverride( + id=rule_id_to_use, + enabled=True, + action="log" + ) + + categories_override = CategoriesOverride( + category="wordpress", + enabled=True, + action="log" + ) + + overrides = Overrides( + action="log", + enabled=True, + rules=[rules_override] if rule_id_to_use else [], + categories=[categories_override] + ) + + action_params = ActionParameters( + id=self.zone_ruleset_to_deploy2, + overrides=overrides + ) + + position = Position(index=1) + + + response = self.rulesets_service.create_zone_ruleset_rule( + ruleset_id=self.ruleset_for_testing_id, + action="execute", + action_parameters=action_params, + description="deploying managed rule", + enabled=True, + expression="ip.src ne 1.1.1.3", + ref=self.ruleset_for_testing_id, + position=position + ) + + self.assertIsNotNone(response.get_result()) + + def test_create_zone_ruleset_rule_skip(self): + + response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_custom" + ) + self.assertEqual(response.get_status_code(), 200) + custom_ruleset_id = response.get_result()['result']['id'] + self.assertIsNotNone(custom_ruleset_id, "Custom ruleset ID is None") + + + action_parameters = ActionParameters( + phases=["http_ratelimit", "http_request_firewall_managed"], + products=["waf"] + ) + + + rule_response = self.rulesets_service.create_zone_ruleset_rule( + ruleset_id=custom_ruleset_id, + action="skip", + action_parameters=action_parameters, + description="deploying custom rule", + enabled=True, + expression="ip.src ne 1.1.1.3", + ref=self.ruleset_for_testing_id + ) + + self.assertEqual(rule_response.get_status_code(), 200) + self.assertIsNotNone(rule_response.get_result()) + + def test_update_delete_zone_ruleset_rule_skip(self): + + response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_custom" + ) + self.assertEqual(response.get_status_code(), 200) + ruleset_result = response.get_result()['result'] + self.assertIsNotNone(ruleset_result, "Ruleset result is None") + + + rules = ruleset_result.get('rules', []) + self.assertGreater(len(rules), 0, "No rules found in the ruleset") + last_rule = rules[-1] + custom_rule_id = last_rule['id'] + custom_ruleset_id = ruleset_result['id'] + + + action_parameters = ActionParameters( + phases=["http_ratelimit", "http_request_firewall_managed"], + products=["waf"] + ) + + + update_response = self.rulesets_service.update_zone_ruleset_rule( + ruleset_id=custom_ruleset_id, + rule_id=custom_rule_id, + action="skip", + action_parameters=action_parameters, + description="Updating the rule with correct IDs", + enabled=True, + expression="ip.src ne 1.1.1.4" + ) + self.assertEqual(update_response.get_status_code(), 200) + + + delete_response = self.rulesets_service.delete_zone_ruleset_rule( + ruleset_id=custom_ruleset_id, + rule_id=custom_rule_id + ) + self.assertEqual(delete_response.get_status_code(), 200) + + + def test_create_zone_ruleset_rule_http_ratelimit(self): + + response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_ratelimit" + ) + self.assertEqual(response.get_status_code(), 200) + + + rulesetEPRatelimitTestingId = response.get_result()['result']['id'] + self.assertIsNotNone(rulesetEPRatelimitTestingId, "Ratelimit ruleset ID not found") + + + ratelimit = Ratelimit( + characteristics=["cf.colo.id", "ip.src"], + counting_expression='(http.host eq "www.example.com") and (http.response.code eq 404)', + mitigation_timeout=600, + period=60, + requests_per_period=100 + ) + + + create_rule_options = { + "ruleset_id": rulesetEPRatelimitTestingId, + "action": "block", + "description": "deploying managed rule", + "enabled": True, + "expression": "ip.src ne 1.1.1.3", + "ref": rulesetEPRatelimitTestingId, + "ratelimit": ratelimit + } + + detailed_response = self.rulesets_service.create_zone_ruleset_rule(**create_rule_options) + + + self.assertEqual(detailed_response.get_status_code(), 200) + self.assertIsNotNone(detailed_response.get_result()) + + def test_update_delete_zone_ruleset_rule_http_ratelimit(self): + + detailed_response = self.rulesets_service.get_zone_entrypoint_ruleset( + ruleset_phase="http_ratelimit" + ) + self.assertEqual(detailed_response.get_status_code(), 200) + + ruleset_result = detailed_response.get_result()['result'] + self.assertIsNotNone(ruleset_result, "Ruleset result is None") + + + rules = ruleset_result.get('rules', []) + self.assertGreater(len(rules), 0, "No rules found in the ruleset") + rule_id = rules[0]['id'] + ruleset_id = ruleset_result['id'] + + + ratelimit = Ratelimit( + characteristics=["cf.colo.id", "ip.src"], + counting_expression='(http.host eq "www.example.com") and (http.response.code eq 404)', + mitigation_timeout=30, + period=10, + requests_per_period=5 + ) + + + update_options = { + "ruleset_id": ruleset_id, + "rule_id": rule_id, + "action": "block", + "description": "updating the rule", + "enabled": True, + "expression": "ip.src ne 1.1.1.4", + "ref": ruleset_id, + "ratelimit": ratelimit + } + + update_response = self.rulesets_service.update_zone_ruleset_rule(**update_options) + self.assertEqual(update_response.get_status_code(), 200) + self.assertIsNotNone(update_response.get_result()) + + + delete_options = { + "ruleset_id": ruleset_id, + "rule_id": rule_id + } + + delete_response = self.rulesets_service.delete_zone_ruleset_rule(**delete_options) + self.assertEqual(delete_response.get_status_code(), 200) + self.assertIsNotNone(delete_response.get_result()) + + + def test_delete_zone_ruleset(self): + if not self.ruleset_for_testing_id: + + resp = self.rulesets_service.update_zone_entrypoint_ruleset( + ruleset_phase="http_request_firewall_managed", + description="temporary ruleset for delete test" + ) + self.__class__.ruleset_for_testing_id = resp.get_result()['result']['id'] + + response = self.rulesets_service.delete_zone_ruleset(self.ruleset_for_testing_id) + self.assertEqual(response.get_status_code(), 204) + self.__class__.ruleset_for_testing_id = None \ No newline at end of file diff --git a/test/unit/test_rulesets_v1.py b/test/unit/test_rulesets_v1.py new file mode 100644 index 0000000..9b69e53 --- /dev/null +++ b/test/unit/test_rulesets_v1.py @@ -0,0 +1,4470 @@ +# -*- coding: utf-8 -*- +# (C) Copyright IBM Corp. 2025. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Unit Tests for RulesetsV1 +""" + +from ibm_cloud_sdk_core.authenticators.no_auth_authenticator import NoAuthAuthenticator +import inspect +import json +import os +import pytest +import re +import responses +import urllib +from ibm_cloud_networking_services.rulesets_v1 import * + +crn = 'testString' +zone_identifier = 'testString' + +_service = RulesetsV1( + authenticator=NoAuthAuthenticator(), + crn=crn, + zone_identifier=zone_identifier, +) + +_base_url = 'https://api.cis.cloud.ibm.com' +_service.set_service_url(_base_url) + + +def preprocess_url(operation_path: str): + """ + Returns the request url associated with the specified operation path. + This will be base_url concatenated with a quoted version of operation_path. + The returned request URL is used to register the mock response so it needs + to match the request URL that is formed by the requests library. + """ + + # Form the request URL from the base URL and operation path. + request_url = _base_url + operation_path + + # If the request url does NOT end with a /, then just return it as-is. + # Otherwise, return a regular expression that matches one or more trailing /. + if not request_url.endswith('/'): + return request_url + return re.compile(request_url.rstrip('/') + '/+') + + +############################################################################## +# Start of Service: InstanceRulesets +############################################################################## +# region + + +class TestNewInstance: + """ + Test Class for new_instance + """ + + def test_new_instance(self): + """ + new_instance() + """ + os.environ['TEST_SERVICE_AUTH_TYPE'] = 'noAuth' + + service = RulesetsV1.new_instance( + crn=crn, + zone_identifier=zone_identifier, + service_name='TEST_SERVICE', + ) + + assert service is not None + assert isinstance(service, RulesetsV1) + + def test_new_instance_without_authenticator(self): + """ + new_instance_without_authenticator() + """ + with pytest.raises(ValueError, match='authenticator must be provided'): + service = RulesetsV1.new_instance( + crn=crn, + zone_identifier=zone_identifier, + service_name='TEST_SERVICE_NOT_FOUND', + ) + + def test_new_instance_without_required_params(self): + """ + new_instance_without_required_params() + """ + with pytest.raises(TypeError, match='new_instance\\(\\) missing \\d required positional arguments?: \'.*\''): + service = RulesetsV1.new_instance() + + def test_new_instance_required_param_none(self): + """ + new_instance_required_param_none() + """ + with pytest.raises(ValueError, match='crn must be provided must be provided'): + service = RulesetsV1.new_instance( + crn=None, + zone_identifier=None, + ) + + +class TestGetInstanceRulesets: + """ + Test Class for get_instance_rulesets + """ + + @responses.activate + def test_get_instance_rulesets_all_params(self): + """ + get_instance_rulesets() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Invoke method + response = _service.get_instance_rulesets() + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_rulesets_all_params_with_retries(self): + # Enable retries and run test_get_instance_rulesets_all_params. + _service.enable_retries() + self.test_get_instance_rulesets_all_params() + + # Disable retries and run test_get_instance_rulesets_all_params. + _service.disable_retries() + self.test_get_instance_rulesets_all_params() + + @responses.activate + def test_get_instance_rulesets_value_error(self): + """ + test_get_instance_rulesets_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_rulesets(**req_copy) + + def test_get_instance_rulesets_value_error_with_retries(self): + # Enable retries and run test_get_instance_rulesets_value_error. + _service.enable_retries() + self.test_get_instance_rulesets_value_error() + + # Disable retries and run test_get_instance_rulesets_value_error. + _service.disable_retries() + self.test_get_instance_rulesets_value_error() + + +class TestGetInstanceRuleset: + """ + Test Class for get_instance_ruleset + """ + + @responses.activate + def test_get_instance_ruleset_all_params(self): + """ + get_instance_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.get_instance_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_ruleset_all_params_with_retries(self): + # Enable retries and run test_get_instance_ruleset_all_params. + _service.enable_retries() + self.test_get_instance_ruleset_all_params() + + # Disable retries and run test_get_instance_ruleset_all_params. + _service.disable_retries() + self.test_get_instance_ruleset_all_params() + + @responses.activate + def test_get_instance_ruleset_value_error(self): + """ + test_get_instance_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_ruleset(**req_copy) + + def test_get_instance_ruleset_value_error_with_retries(self): + # Enable retries and run test_get_instance_ruleset_value_error. + _service.enable_retries() + self.test_get_instance_ruleset_value_error() + + # Disable retries and run test_get_instance_ruleset_value_error. + _service.disable_retries() + self.test_get_instance_ruleset_value_error() + + +class TestUpdateInstanceRuleset: + """ + Test Class for update_instance_ruleset + """ + + @responses.activate + def test_update_instance_ruleset_all_params(self): + """ + update_instance_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Construct a dict representation of a RuleCreate model + rule_create_model = {} + rule_create_model['action'] = 'testString' + rule_create_model['action_parameters'] = action_parameters_model + rule_create_model['ratelimit'] = ratelimit_model + rule_create_model['description'] = 'testString' + rule_create_model['enabled'] = True + rule_create_model['expression'] = 'ip.src ne 1.1.1.1' + rule_create_model['id'] = 'testString' + rule_create_model['logging'] = logging_model + rule_create_model['ref'] = 'my_ref' + rule_create_model['position'] = position_model + + # Set up parameter values + ruleset_id = 'testString' + description = 'Custom instance ruleset' + kind = 'managed' + name = 'testString' + phase = 'ddos_l4' + rules = [rule_create_model] + + # Invoke method + response = _service.update_instance_ruleset( + ruleset_id, + description=description, + kind=kind, + name=name, + phase=phase, + rules=rules, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['description'] == 'Custom instance ruleset' + assert req_body['kind'] == 'managed' + assert req_body['name'] == 'testString' + assert req_body['phase'] == 'ddos_l4' + assert req_body['rules'] == [rule_create_model] + + def test_update_instance_ruleset_all_params_with_retries(self): + # Enable retries and run test_update_instance_ruleset_all_params. + _service.enable_retries() + self.test_update_instance_ruleset_all_params() + + # Disable retries and run test_update_instance_ruleset_all_params. + _service.disable_retries() + self.test_update_instance_ruleset_all_params() + + @responses.activate + def test_update_instance_ruleset_required_params(self): + """ + test_update_instance_ruleset_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.update_instance_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_instance_ruleset_required_params_with_retries(self): + # Enable retries and run test_update_instance_ruleset_required_params. + _service.enable_retries() + self.test_update_instance_ruleset_required_params() + + # Disable retries and run test_update_instance_ruleset_required_params. + _service.disable_retries() + self.test_update_instance_ruleset_required_params() + + @responses.activate + def test_update_instance_ruleset_value_error(self): + """ + test_update_instance_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_instance_ruleset(**req_copy) + + def test_update_instance_ruleset_value_error_with_retries(self): + # Enable retries and run test_update_instance_ruleset_value_error. + _service.enable_retries() + self.test_update_instance_ruleset_value_error() + + # Disable retries and run test_update_instance_ruleset_value_error. + _service.disable_retries() + self.test_update_instance_ruleset_value_error() + + +class TestDeleteInstanceRuleset: + """ + Test Class for delete_instance_ruleset + """ + + @responses.activate + def test_delete_instance_ruleset_all_params(self): + """ + delete_instance_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.delete_instance_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 204 + + def test_delete_instance_ruleset_all_params_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_all_params. + _service.enable_retries() + self.test_delete_instance_ruleset_all_params() + + # Disable retries and run test_delete_instance_ruleset_all_params. + _service.disable_retries() + self.test_delete_instance_ruleset_all_params() + + @responses.activate + def test_delete_instance_ruleset_value_error(self): + """ + test_delete_instance_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_instance_ruleset(**req_copy) + + def test_delete_instance_ruleset_value_error_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_value_error. + _service.enable_retries() + self.test_delete_instance_ruleset_value_error() + + # Disable retries and run test_delete_instance_ruleset_value_error. + _service.disable_retries() + self.test_delete_instance_ruleset_value_error() + + +class TestGetInstanceRulesetVersions: + """ + Test Class for get_instance_ruleset_versions + """ + + @responses.activate + def test_get_instance_ruleset_versions_all_params(self): + """ + get_instance_ruleset_versions() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.get_instance_ruleset_versions( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_ruleset_versions_all_params_with_retries(self): + # Enable retries and run test_get_instance_ruleset_versions_all_params. + _service.enable_retries() + self.test_get_instance_ruleset_versions_all_params() + + # Disable retries and run test_get_instance_ruleset_versions_all_params. + _service.disable_retries() + self.test_get_instance_ruleset_versions_all_params() + + @responses.activate + def test_get_instance_ruleset_versions_value_error(self): + """ + test_get_instance_ruleset_versions_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_ruleset_versions(**req_copy) + + def test_get_instance_ruleset_versions_value_error_with_retries(self): + # Enable retries and run test_get_instance_ruleset_versions_value_error. + _service.enable_retries() + self.test_get_instance_ruleset_versions_value_error() + + # Disable retries and run test_get_instance_ruleset_versions_value_error. + _service.disable_retries() + self.test_get_instance_ruleset_versions_value_error() + + +class TestGetInstanceRulesetVersion: + """ + Test Class for get_instance_ruleset_version + """ + + @responses.activate + def test_get_instance_ruleset_version_all_params(self): + """ + get_instance_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Invoke method + response = _service.get_instance_ruleset_version( + ruleset_id, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_get_instance_ruleset_version_all_params. + _service.enable_retries() + self.test_get_instance_ruleset_version_all_params() + + # Disable retries and run test_get_instance_ruleset_version_all_params. + _service.disable_retries() + self.test_get_instance_ruleset_version_all_params() + + @responses.activate + def test_get_instance_ruleset_version_value_error(self): + """ + test_get_instance_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_ruleset_version(**req_copy) + + def test_get_instance_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_get_instance_ruleset_version_value_error. + _service.enable_retries() + self.test_get_instance_ruleset_version_value_error() + + # Disable retries and run test_get_instance_ruleset_version_value_error. + _service.disable_retries() + self.test_get_instance_ruleset_version_value_error() + + +class TestDeleteInstanceRulesetVersion: + """ + Test Class for delete_instance_ruleset_version + """ + + @responses.activate + def test_delete_instance_ruleset_version_all_params(self): + """ + delete_instance_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Invoke method + response = _service.delete_instance_ruleset_version( + ruleset_id, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 204 + + def test_delete_instance_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_version_all_params. + _service.enable_retries() + self.test_delete_instance_ruleset_version_all_params() + + # Disable retries and run test_delete_instance_ruleset_version_all_params. + _service.disable_retries() + self.test_delete_instance_ruleset_version_all_params() + + @responses.activate + def test_delete_instance_ruleset_version_value_error(self): + """ + test_delete_instance_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_instance_ruleset_version(**req_copy) + + def test_delete_instance_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_version_value_error. + _service.enable_retries() + self.test_delete_instance_ruleset_version_value_error() + + # Disable retries and run test_delete_instance_ruleset_version_value_error. + _service.disable_retries() + self.test_delete_instance_ruleset_version_value_error() + + +class TestGetInstanceEntrypointRuleset: + """ + Test Class for get_instance_entrypoint_ruleset + """ + + @responses.activate + def test_get_instance_entrypoint_ruleset_all_params(self): + """ + get_instance_entrypoint_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.get_instance_entrypoint_ruleset( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_entrypoint_ruleset_all_params_with_retries(self): + # Enable retries and run test_get_instance_entrypoint_ruleset_all_params. + _service.enable_retries() + self.test_get_instance_entrypoint_ruleset_all_params() + + # Disable retries and run test_get_instance_entrypoint_ruleset_all_params. + _service.disable_retries() + self.test_get_instance_entrypoint_ruleset_all_params() + + @responses.activate + def test_get_instance_entrypoint_ruleset_value_error(self): + """ + test_get_instance_entrypoint_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_entrypoint_ruleset(**req_copy) + + def test_get_instance_entrypoint_ruleset_value_error_with_retries(self): + # Enable retries and run test_get_instance_entrypoint_ruleset_value_error. + _service.enable_retries() + self.test_get_instance_entrypoint_ruleset_value_error() + + # Disable retries and run test_get_instance_entrypoint_ruleset_value_error. + _service.disable_retries() + self.test_get_instance_entrypoint_ruleset_value_error() + + +class TestUpdateInstanceEntrypointRuleset: + """ + Test Class for update_instance_entrypoint_ruleset + """ + + @responses.activate + def test_update_instance_entrypoint_ruleset_all_params(self): + """ + update_instance_entrypoint_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Construct a dict representation of a RuleCreate model + rule_create_model = {} + rule_create_model['action'] = 'testString' + rule_create_model['action_parameters'] = action_parameters_model + rule_create_model['ratelimit'] = ratelimit_model + rule_create_model['description'] = 'testString' + rule_create_model['enabled'] = True + rule_create_model['expression'] = 'ip.src ne 1.1.1.1' + rule_create_model['id'] = 'testString' + rule_create_model['logging'] = logging_model + rule_create_model['ref'] = 'my_ref' + rule_create_model['position'] = position_model + + # Set up parameter values + ruleset_phase = 'ddos_l4' + description = 'Custom instance ruleset' + kind = 'managed' + name = 'testString' + phase = 'ddos_l4' + rules = [rule_create_model] + + # Invoke method + response = _service.update_instance_entrypoint_ruleset( + ruleset_phase, + description=description, + kind=kind, + name=name, + phase=phase, + rules=rules, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['description'] == 'Custom instance ruleset' + assert req_body['kind'] == 'managed' + assert req_body['name'] == 'testString' + assert req_body['phase'] == 'ddos_l4' + assert req_body['rules'] == [rule_create_model] + + def test_update_instance_entrypoint_ruleset_all_params_with_retries(self): + # Enable retries and run test_update_instance_entrypoint_ruleset_all_params. + _service.enable_retries() + self.test_update_instance_entrypoint_ruleset_all_params() + + # Disable retries and run test_update_instance_entrypoint_ruleset_all_params. + _service.disable_retries() + self.test_update_instance_entrypoint_ruleset_all_params() + + @responses.activate + def test_update_instance_entrypoint_ruleset_required_params(self): + """ + test_update_instance_entrypoint_ruleset_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.update_instance_entrypoint_ruleset( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_instance_entrypoint_ruleset_required_params_with_retries(self): + # Enable retries and run test_update_instance_entrypoint_ruleset_required_params. + _service.enable_retries() + self.test_update_instance_entrypoint_ruleset_required_params() + + # Disable retries and run test_update_instance_entrypoint_ruleset_required_params. + _service.disable_retries() + self.test_update_instance_entrypoint_ruleset_required_params() + + @responses.activate + def test_update_instance_entrypoint_ruleset_value_error(self): + """ + test_update_instance_entrypoint_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_instance_entrypoint_ruleset(**req_copy) + + def test_update_instance_entrypoint_ruleset_value_error_with_retries(self): + # Enable retries and run test_update_instance_entrypoint_ruleset_value_error. + _service.enable_retries() + self.test_update_instance_entrypoint_ruleset_value_error() + + # Disable retries and run test_update_instance_entrypoint_ruleset_value_error. + _service.disable_retries() + self.test_update_instance_entrypoint_ruleset_value_error() + + +class TestGetInstanceEntryPointRulesetVersions: + """ + Test Class for get_instance_entry_point_ruleset_versions + """ + + @responses.activate + def test_get_instance_entry_point_ruleset_versions_all_params(self): + """ + get_instance_entry_point_ruleset_versions() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.get_instance_entry_point_ruleset_versions( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_entry_point_ruleset_versions_all_params_with_retries(self): + # Enable retries and run test_get_instance_entry_point_ruleset_versions_all_params. + _service.enable_retries() + self.test_get_instance_entry_point_ruleset_versions_all_params() + + # Disable retries and run test_get_instance_entry_point_ruleset_versions_all_params. + _service.disable_retries() + self.test_get_instance_entry_point_ruleset_versions_all_params() + + @responses.activate + def test_get_instance_entry_point_ruleset_versions_value_error(self): + """ + test_get_instance_entry_point_ruleset_versions_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_entry_point_ruleset_versions(**req_copy) + + def test_get_instance_entry_point_ruleset_versions_value_error_with_retries(self): + # Enable retries and run test_get_instance_entry_point_ruleset_versions_value_error. + _service.enable_retries() + self.test_get_instance_entry_point_ruleset_versions_value_error() + + # Disable retries and run test_get_instance_entry_point_ruleset_versions_value_error. + _service.disable_retries() + self.test_get_instance_entry_point_ruleset_versions_value_error() + + +class TestGetInstanceEntryPointRulesetVersion: + """ + Test Class for get_instance_entry_point_ruleset_version + """ + + @responses.activate + def test_get_instance_entry_point_ruleset_version_all_params(self): + """ + get_instance_entry_point_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + ruleset_version = '1' + + # Invoke method + response = _service.get_instance_entry_point_ruleset_version( + ruleset_phase, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_entry_point_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_get_instance_entry_point_ruleset_version_all_params. + _service.enable_retries() + self.test_get_instance_entry_point_ruleset_version_all_params() + + # Disable retries and run test_get_instance_entry_point_ruleset_version_all_params. + _service.disable_retries() + self.test_get_instance_entry_point_ruleset_version_all_params() + + @responses.activate + def test_get_instance_entry_point_ruleset_version_value_error(self): + """ + test_get_instance_entry_point_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/phases/ddos_l4/entrypoint/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_entry_point_ruleset_version(**req_copy) + + def test_get_instance_entry_point_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_get_instance_entry_point_ruleset_version_value_error. + _service.enable_retries() + self.test_get_instance_entry_point_ruleset_version_value_error() + + # Disable retries and run test_get_instance_entry_point_ruleset_version_value_error. + _service.disable_retries() + self.test_get_instance_entry_point_ruleset_version_value_error() + + +class TestCreateInstanceRulesetRule: + """ + Test Class for create_instance_ruleset_rule + """ + + @responses.activate + def test_create_instance_ruleset_rule_all_params(self): + """ + create_instance_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Set up parameter values + ruleset_id = 'testString' + action = 'testString' + expression = 'ip.src ne 1.1.1.1' + action_parameters = action_parameters_model + ratelimit = ratelimit_model + description = 'testString' + enabled = True + id = 'testString' + logging = logging_model + ref = 'my_ref' + position = position_model + + # Invoke method + response = _service.create_instance_ruleset_rule( + ruleset_id, + action=action, + expression=expression, + action_parameters=action_parameters, + ratelimit=ratelimit, + description=description, + enabled=enabled, + id=id, + logging=logging, + ref=ref, + position=position, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['action'] == 'testString' + assert req_body['expression'] == 'ip.src ne 1.1.1.1' + assert req_body['action_parameters'] == action_parameters_model + assert req_body['ratelimit'] == ratelimit_model + assert req_body['description'] == 'testString' + assert req_body['enabled'] == True + assert req_body['id'] == 'testString' + assert req_body['logging'] == logging_model + assert req_body['ref'] == 'my_ref' + assert req_body['position'] == position_model + + def test_create_instance_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_create_instance_ruleset_rule_all_params. + _service.enable_retries() + self.test_create_instance_ruleset_rule_all_params() + + # Disable retries and run test_create_instance_ruleset_rule_all_params. + _service.disable_retries() + self.test_create_instance_ruleset_rule_all_params() + + @responses.activate + def test_create_instance_ruleset_rule_required_params(self): + """ + test_create_instance_ruleset_rule_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.create_instance_ruleset_rule( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_create_instance_ruleset_rule_required_params_with_retries(self): + # Enable retries and run test_create_instance_ruleset_rule_required_params. + _service.enable_retries() + self.test_create_instance_ruleset_rule_required_params() + + # Disable retries and run test_create_instance_ruleset_rule_required_params. + _service.disable_retries() + self.test_create_instance_ruleset_rule_required_params() + + @responses.activate + def test_create_instance_ruleset_rule_value_error(self): + """ + test_create_instance_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.create_instance_ruleset_rule(**req_copy) + + def test_create_instance_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_create_instance_ruleset_rule_value_error. + _service.enable_retries() + self.test_create_instance_ruleset_rule_value_error() + + # Disable retries and run test_create_instance_ruleset_rule_value_error. + _service.disable_retries() + self.test_create_instance_ruleset_rule_value_error() + + +class TestUpdateInstanceRulesetRule: + """ + Test Class for update_instance_ruleset_rule + """ + + @responses.activate + def test_update_instance_ruleset_rule_all_params(self): + """ + update_instance_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + action = 'testString' + action_parameters = action_parameters_model + ratelimit = ratelimit_model + description = 'testString' + enabled = True + expression = 'ip.src ne 1.1.1.1' + id = 'testString' + logging = logging_model + ref = 'my_ref' + position = position_model + + # Invoke method + response = _service.update_instance_ruleset_rule( + ruleset_id, + rule_id, + action=action, + action_parameters=action_parameters, + ratelimit=ratelimit, + description=description, + enabled=enabled, + expression=expression, + id=id, + logging=logging, + ref=ref, + position=position, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['action'] == 'testString' + assert req_body['action_parameters'] == action_parameters_model + assert req_body['ratelimit'] == ratelimit_model + assert req_body['description'] == 'testString' + assert req_body['enabled'] == True + assert req_body['expression'] == 'ip.src ne 1.1.1.1' + assert req_body['id'] == 'testString' + assert req_body['logging'] == logging_model + assert req_body['ref'] == 'my_ref' + assert req_body['position'] == position_model + + def test_update_instance_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_update_instance_ruleset_rule_all_params. + _service.enable_retries() + self.test_update_instance_ruleset_rule_all_params() + + # Disable retries and run test_update_instance_ruleset_rule_all_params. + _service.disable_retries() + self.test_update_instance_ruleset_rule_all_params() + + @responses.activate + def test_update_instance_ruleset_rule_required_params(self): + """ + test_update_instance_ruleset_rule_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Invoke method + response = _service.update_instance_ruleset_rule( + ruleset_id, + rule_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_instance_ruleset_rule_required_params_with_retries(self): + # Enable retries and run test_update_instance_ruleset_rule_required_params. + _service.enable_retries() + self.test_update_instance_ruleset_rule_required_params() + + # Disable retries and run test_update_instance_ruleset_rule_required_params. + _service.disable_retries() + self.test_update_instance_ruleset_rule_required_params() + + @responses.activate + def test_update_instance_ruleset_rule_value_error(self): + """ + test_update_instance_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "rule_id": rule_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_instance_ruleset_rule(**req_copy) + + def test_update_instance_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_update_instance_ruleset_rule_value_error. + _service.enable_retries() + self.test_update_instance_ruleset_rule_value_error() + + # Disable retries and run test_update_instance_ruleset_rule_value_error. + _service.disable_retries() + self.test_update_instance_ruleset_rule_value_error() + + +class TestDeleteInstanceRulesetRule: + """ + Test Class for delete_instance_ruleset_rule + """ + + @responses.activate + def test_delete_instance_ruleset_rule_all_params(self): + """ + delete_instance_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}}' + responses.add( + responses.DELETE, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Invoke method + response = _service.delete_instance_ruleset_rule( + ruleset_id, + rule_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_delete_instance_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_rule_all_params. + _service.enable_retries() + self.test_delete_instance_ruleset_rule_all_params() + + # Disable retries and run test_delete_instance_ruleset_rule_all_params. + _service.disable_retries() + self.test_delete_instance_ruleset_rule_all_params() + + @responses.activate + def test_delete_instance_ruleset_rule_value_error(self): + """ + test_delete_instance_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}}' + responses.add( + responses.DELETE, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "rule_id": rule_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_instance_ruleset_rule(**req_copy) + + def test_delete_instance_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_delete_instance_ruleset_rule_value_error. + _service.enable_retries() + self.test_delete_instance_ruleset_rule_value_error() + + # Disable retries and run test_delete_instance_ruleset_rule_value_error. + _service.disable_retries() + self.test_delete_instance_ruleset_rule_value_error() + + +class TestGetInstanceRulesetVersionByTag: + """ + Test Class for get_instance_ruleset_version_by_tag + """ + + @responses.activate + def test_get_instance_ruleset_version_by_tag_all_params(self): + """ + get_instance_ruleset_version_by_tag() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1/by_tag/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + rule_tag = 'testString' + + # Invoke method + response = _service.get_instance_ruleset_version_by_tag( + ruleset_id, + ruleset_version, + rule_tag, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_instance_ruleset_version_by_tag_all_params_with_retries(self): + # Enable retries and run test_get_instance_ruleset_version_by_tag_all_params. + _service.enable_retries() + self.test_get_instance_ruleset_version_by_tag_all_params() + + # Disable retries and run test_get_instance_ruleset_version_by_tag_all_params. + _service.disable_retries() + self.test_get_instance_ruleset_version_by_tag_all_params() + + @responses.activate + def test_get_instance_ruleset_version_by_tag_value_error(self): + """ + test_get_instance_ruleset_version_by_tag_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/rulesets/testString/versions/1/by_tag/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + rule_tag = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "ruleset_version": ruleset_version, + "rule_tag": rule_tag, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_instance_ruleset_version_by_tag(**req_copy) + + def test_get_instance_ruleset_version_by_tag_value_error_with_retries(self): + # Enable retries and run test_get_instance_ruleset_version_by_tag_value_error. + _service.enable_retries() + self.test_get_instance_ruleset_version_by_tag_value_error() + + # Disable retries and run test_get_instance_ruleset_version_by_tag_value_error. + _service.disable_retries() + self.test_get_instance_ruleset_version_by_tag_value_error() + + +# endregion +############################################################################## +# End of Service: InstanceRulesets +############################################################################## + +############################################################################## +# Start of Service: ZoneRulesets +############################################################################## +# region + + +class TestNewInstance: + """ + Test Class for new_instance + """ + + def test_new_instance(self): + """ + new_instance() + """ + os.environ['TEST_SERVICE_AUTH_TYPE'] = 'noAuth' + + service = RulesetsV1.new_instance( + crn=crn, + zone_identifier=zone_identifier, + service_name='TEST_SERVICE', + ) + + assert service is not None + assert isinstance(service, RulesetsV1) + + def test_new_instance_without_authenticator(self): + """ + new_instance_without_authenticator() + """ + with pytest.raises(ValueError, match='authenticator must be provided'): + service = RulesetsV1.new_instance( + crn=crn, + zone_identifier=zone_identifier, + service_name='TEST_SERVICE_NOT_FOUND', + ) + + def test_new_instance_without_required_params(self): + """ + new_instance_without_required_params() + """ + with pytest.raises(TypeError, match='new_instance\\(\\) missing \\d required positional arguments?: \'.*\''): + service = RulesetsV1.new_instance() + + def test_new_instance_required_param_none(self): + """ + new_instance_required_param_none() + """ + with pytest.raises(ValueError, match='crn must be provided'): + service = RulesetsV1.new_instance( + crn=None, + zone_identifier=None, + ) + + +class TestGetZoneRulesets: + """ + Test Class for get_zone_rulesets + """ + + @responses.activate + def test_get_zone_rulesets_all_params(self): + """ + get_zone_rulesets() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Invoke method + response = _service.get_zone_rulesets() + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_rulesets_all_params_with_retries(self): + # Enable retries and run test_get_zone_rulesets_all_params. + _service.enable_retries() + self.test_get_zone_rulesets_all_params() + + # Disable retries and run test_get_zone_rulesets_all_params. + _service.disable_retries() + self.test_get_zone_rulesets_all_params() + + @responses.activate + def test_get_zone_rulesets_value_error(self): + """ + test_get_zone_rulesets_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_rulesets(**req_copy) + + def test_get_zone_rulesets_value_error_with_retries(self): + # Enable retries and run test_get_zone_rulesets_value_error. + _service.enable_retries() + self.test_get_zone_rulesets_value_error() + + # Disable retries and run test_get_zone_rulesets_value_error. + _service.disable_retries() + self.test_get_zone_rulesets_value_error() + + +class TestGetZoneRuleset: + """ + Test Class for get_zone_ruleset + """ + + @responses.activate + def test_get_zone_ruleset_all_params(self): + """ + get_zone_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.get_zone_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_ruleset_all_params_with_retries(self): + # Enable retries and run test_get_zone_ruleset_all_params. + _service.enable_retries() + self.test_get_zone_ruleset_all_params() + + # Disable retries and run test_get_zone_ruleset_all_params. + _service.disable_retries() + self.test_get_zone_ruleset_all_params() + + @responses.activate + def test_get_zone_ruleset_value_error(self): + """ + test_get_zone_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_ruleset(**req_copy) + + def test_get_zone_ruleset_value_error_with_retries(self): + # Enable retries and run test_get_zone_ruleset_value_error. + _service.enable_retries() + self.test_get_zone_ruleset_value_error() + + # Disable retries and run test_get_zone_ruleset_value_error. + _service.disable_retries() + self.test_get_zone_ruleset_value_error() + + +class TestUpdateZoneRuleset: + """ + Test Class for update_zone_ruleset + """ + + @responses.activate + def test_update_zone_ruleset_all_params(self): + """ + update_zone_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Construct a dict representation of a RuleCreate model + rule_create_model = {} + rule_create_model['action'] = 'testString' + rule_create_model['action_parameters'] = action_parameters_model + rule_create_model['ratelimit'] = ratelimit_model + rule_create_model['description'] = 'testString' + rule_create_model['enabled'] = True + rule_create_model['expression'] = 'ip.src ne 1.1.1.1' + rule_create_model['id'] = 'testString' + rule_create_model['logging'] = logging_model + rule_create_model['ref'] = 'my_ref' + rule_create_model['position'] = position_model + + # Set up parameter values + ruleset_id = 'testString' + description = 'Custom instance ruleset' + kind = 'managed' + name = 'testString' + phase = 'ddos_l4' + rules = [rule_create_model] + + # Invoke method + response = _service.update_zone_ruleset( + ruleset_id, + description=description, + kind=kind, + name=name, + phase=phase, + rules=rules, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['description'] == 'Custom instance ruleset' + assert req_body['kind'] == 'managed' + assert req_body['name'] == 'testString' + assert req_body['phase'] == 'ddos_l4' + assert req_body['rules'] == [rule_create_model] + + def test_update_zone_ruleset_all_params_with_retries(self): + # Enable retries and run test_update_zone_ruleset_all_params. + _service.enable_retries() + self.test_update_zone_ruleset_all_params() + + # Disable retries and run test_update_zone_ruleset_all_params. + _service.disable_retries() + self.test_update_zone_ruleset_all_params() + + @responses.activate + def test_update_zone_ruleset_required_params(self): + """ + test_update_zone_ruleset_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.update_zone_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_zone_ruleset_required_params_with_retries(self): + # Enable retries and run test_update_zone_ruleset_required_params. + _service.enable_retries() + self.test_update_zone_ruleset_required_params() + + # Disable retries and run test_update_zone_ruleset_required_params. + _service.disable_retries() + self.test_update_zone_ruleset_required_params() + + @responses.activate + def test_update_zone_ruleset_value_error(self): + """ + test_update_zone_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_zone_ruleset(**req_copy) + + def test_update_zone_ruleset_value_error_with_retries(self): + # Enable retries and run test_update_zone_ruleset_value_error. + _service.enable_retries() + self.test_update_zone_ruleset_value_error() + + # Disable retries and run test_update_zone_ruleset_value_error. + _service.disable_retries() + self.test_update_zone_ruleset_value_error() + + +class TestDeleteZoneRuleset: + """ + Test Class for delete_zone_ruleset + """ + + @responses.activate + def test_delete_zone_ruleset_all_params(self): + """ + delete_zone_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.delete_zone_ruleset( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 204 + + def test_delete_zone_ruleset_all_params_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_all_params. + _service.enable_retries() + self.test_delete_zone_ruleset_all_params() + + # Disable retries and run test_delete_zone_ruleset_all_params. + _service.disable_retries() + self.test_delete_zone_ruleset_all_params() + + @responses.activate + def test_delete_zone_ruleset_value_error(self): + """ + test_delete_zone_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_zone_ruleset(**req_copy) + + def test_delete_zone_ruleset_value_error_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_value_error. + _service.enable_retries() + self.test_delete_zone_ruleset_value_error() + + # Disable retries and run test_delete_zone_ruleset_value_error. + _service.disable_retries() + self.test_delete_zone_ruleset_value_error() + + +class TestGetZoneRulesetVersions: + """ + Test Class for get_zone_ruleset_versions + """ + + @responses.activate + def test_get_zone_ruleset_versions_all_params(self): + """ + get_zone_ruleset_versions() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.get_zone_ruleset_versions( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_ruleset_versions_all_params_with_retries(self): + # Enable retries and run test_get_zone_ruleset_versions_all_params. + _service.enable_retries() + self.test_get_zone_ruleset_versions_all_params() + + # Disable retries and run test_get_zone_ruleset_versions_all_params. + _service.disable_retries() + self.test_get_zone_ruleset_versions_all_params() + + @responses.activate + def test_get_zone_ruleset_versions_value_error(self): + """ + test_get_zone_ruleset_versions_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_ruleset_versions(**req_copy) + + def test_get_zone_ruleset_versions_value_error_with_retries(self): + # Enable retries and run test_get_zone_ruleset_versions_value_error. + _service.enable_retries() + self.test_get_zone_ruleset_versions_value_error() + + # Disable retries and run test_get_zone_ruleset_versions_value_error. + _service.disable_retries() + self.test_get_zone_ruleset_versions_value_error() + + +class TestGetZoneRulesetVersion: + """ + Test Class for get_zone_ruleset_version + """ + + @responses.activate + def test_get_zone_ruleset_version_all_params(self): + """ + get_zone_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Invoke method + response = _service.get_zone_ruleset_version( + ruleset_id, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_get_zone_ruleset_version_all_params. + _service.enable_retries() + self.test_get_zone_ruleset_version_all_params() + + # Disable retries and run test_get_zone_ruleset_version_all_params. + _service.disable_retries() + self.test_get_zone_ruleset_version_all_params() + + @responses.activate + def test_get_zone_ruleset_version_value_error(self): + """ + test_get_zone_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_ruleset_version(**req_copy) + + def test_get_zone_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_get_zone_ruleset_version_value_error. + _service.enable_retries() + self.test_get_zone_ruleset_version_value_error() + + # Disable retries and run test_get_zone_ruleset_version_value_error. + _service.disable_retries() + self.test_get_zone_ruleset_version_value_error() + + +class TestDeleteZoneRulesetVersion: + """ + Test Class for delete_zone_ruleset_version + """ + + @responses.activate + def test_delete_zone_ruleset_version_all_params(self): + """ + delete_zone_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions/1') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Invoke method + response = _service.delete_zone_ruleset_version( + ruleset_id, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 204 + + def test_delete_zone_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_version_all_params. + _service.enable_retries() + self.test_delete_zone_ruleset_version_all_params() + + # Disable retries and run test_delete_zone_ruleset_version_all_params. + _service.disable_retries() + self.test_delete_zone_ruleset_version_all_params() + + @responses.activate + def test_delete_zone_ruleset_version_value_error(self): + """ + test_delete_zone_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/versions/1') + responses.add( + responses.DELETE, + url, + status=204, + ) + + # Set up parameter values + ruleset_id = 'testString' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_zone_ruleset_version(**req_copy) + + def test_delete_zone_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_version_value_error. + _service.enable_retries() + self.test_delete_zone_ruleset_version_value_error() + + # Disable retries and run test_delete_zone_ruleset_version_value_error. + _service.disable_retries() + self.test_delete_zone_ruleset_version_value_error() + + +class TestGetZoneEntrypointRuleset: + """ + Test Class for get_zone_entrypoint_ruleset + """ + + @responses.activate + def test_get_zone_entrypoint_ruleset_all_params(self): + """ + get_zone_entrypoint_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.get_zone_entrypoint_ruleset( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_entrypoint_ruleset_all_params_with_retries(self): + # Enable retries and run test_get_zone_entrypoint_ruleset_all_params. + _service.enable_retries() + self.test_get_zone_entrypoint_ruleset_all_params() + + # Disable retries and run test_get_zone_entrypoint_ruleset_all_params. + _service.disable_retries() + self.test_get_zone_entrypoint_ruleset_all_params() + + @responses.activate + def test_get_zone_entrypoint_ruleset_value_error(self): + """ + test_get_zone_entrypoint_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_entrypoint_ruleset(**req_copy) + + def test_get_zone_entrypoint_ruleset_value_error_with_retries(self): + # Enable retries and run test_get_zone_entrypoint_ruleset_value_error. + _service.enable_retries() + self.test_get_zone_entrypoint_ruleset_value_error() + + # Disable retries and run test_get_zone_entrypoint_ruleset_value_error. + _service.disable_retries() + self.test_get_zone_entrypoint_ruleset_value_error() + + +class TestUpdateZoneEntrypointRuleset: + """ + Test Class for update_zone_entrypoint_ruleset + """ + + @responses.activate + def test_update_zone_entrypoint_ruleset_all_params(self): + """ + update_zone_entrypoint_ruleset() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Construct a dict representation of a RuleCreate model + rule_create_model = {} + rule_create_model['action'] = 'testString' + rule_create_model['action_parameters'] = action_parameters_model + rule_create_model['ratelimit'] = ratelimit_model + rule_create_model['description'] = 'testString' + rule_create_model['enabled'] = True + rule_create_model['expression'] = 'ip.src ne 1.1.1.1' + rule_create_model['id'] = 'testString' + rule_create_model['logging'] = logging_model + rule_create_model['ref'] = 'my_ref' + rule_create_model['position'] = position_model + + # Set up parameter values + ruleset_phase = 'ddos_l4' + description = 'Custom instance ruleset' + kind = 'managed' + name = 'testString' + phase = 'ddos_l4' + rules = [rule_create_model] + + # Invoke method + response = _service.update_zone_entrypoint_ruleset( + ruleset_phase, + description=description, + kind=kind, + name=name, + phase=phase, + rules=rules, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['description'] == 'Custom instance ruleset' + assert req_body['kind'] == 'managed' + assert req_body['name'] == 'testString' + assert req_body['phase'] == 'ddos_l4' + assert req_body['rules'] == [rule_create_model] + + def test_update_zone_entrypoint_ruleset_all_params_with_retries(self): + # Enable retries and run test_update_zone_entrypoint_ruleset_all_params. + _service.enable_retries() + self.test_update_zone_entrypoint_ruleset_all_params() + + # Disable retries and run test_update_zone_entrypoint_ruleset_all_params. + _service.disable_retries() + self.test_update_zone_entrypoint_ruleset_all_params() + + @responses.activate + def test_update_zone_entrypoint_ruleset_required_params(self): + """ + test_update_zone_entrypoint_ruleset_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.update_zone_entrypoint_ruleset( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_zone_entrypoint_ruleset_required_params_with_retries(self): + # Enable retries and run test_update_zone_entrypoint_ruleset_required_params. + _service.enable_retries() + self.test_update_zone_entrypoint_ruleset_required_params() + + # Disable retries and run test_update_zone_entrypoint_ruleset_required_params. + _service.disable_retries() + self.test_update_zone_entrypoint_ruleset_required_params() + + @responses.activate + def test_update_zone_entrypoint_ruleset_value_error(self): + """ + test_update_zone_entrypoint_ruleset_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PUT, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_zone_entrypoint_ruleset(**req_copy) + + def test_update_zone_entrypoint_ruleset_value_error_with_retries(self): + # Enable retries and run test_update_zone_entrypoint_ruleset_value_error. + _service.enable_retries() + self.test_update_zone_entrypoint_ruleset_value_error() + + # Disable retries and run test_update_zone_entrypoint_ruleset_value_error. + _service.disable_retries() + self.test_update_zone_entrypoint_ruleset_value_error() + + +class TestGetZoneEntryPointRulesetVersions: + """ + Test Class for get_zone_entry_point_ruleset_versions + """ + + @responses.activate + def test_get_zone_entry_point_ruleset_versions_all_params(self): + """ + get_zone_entry_point_ruleset_versions() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Invoke method + response = _service.get_zone_entry_point_ruleset_versions( + ruleset_phase, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_entry_point_ruleset_versions_all_params_with_retries(self): + # Enable retries and run test_get_zone_entry_point_ruleset_versions_all_params. + _service.enable_retries() + self.test_get_zone_entry_point_ruleset_versions_all_params() + + # Disable retries and run test_get_zone_entry_point_ruleset_versions_all_params. + _service.disable_retries() + self.test_get_zone_entry_point_ruleset_versions_all_params() + + @responses.activate + def test_get_zone_entry_point_ruleset_versions_value_error(self): + """ + test_get_zone_entry_point_ruleset_versions_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint/versions') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": [{"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1"}]}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_entry_point_ruleset_versions(**req_copy) + + def test_get_zone_entry_point_ruleset_versions_value_error_with_retries(self): + # Enable retries and run test_get_zone_entry_point_ruleset_versions_value_error. + _service.enable_retries() + self.test_get_zone_entry_point_ruleset_versions_value_error() + + # Disable retries and run test_get_zone_entry_point_ruleset_versions_value_error. + _service.disable_retries() + self.test_get_zone_entry_point_ruleset_versions_value_error() + + +class TestGetZoneEntryPointRulesetVersion: + """ + Test Class for get_zone_entry_point_ruleset_version + """ + + @responses.activate + def test_get_zone_entry_point_ruleset_version_all_params(self): + """ + get_zone_entry_point_ruleset_version() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + ruleset_version = '1' + + # Invoke method + response = _service.get_zone_entry_point_ruleset_version( + ruleset_phase, + ruleset_version, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_get_zone_entry_point_ruleset_version_all_params_with_retries(self): + # Enable retries and run test_get_zone_entry_point_ruleset_version_all_params. + _service.enable_retries() + self.test_get_zone_entry_point_ruleset_version_all_params() + + # Disable retries and run test_get_zone_entry_point_ruleset_version_all_params. + _service.disable_retries() + self.test_get_zone_entry_point_ruleset_version_all_params() + + @responses.activate + def test_get_zone_entry_point_ruleset_version_value_error(self): + """ + test_get_zone_entry_point_ruleset_version_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/phases/ddos_l4/entrypoint/versions/1') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.GET, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_phase = 'ddos_l4' + ruleset_version = '1' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_phase": ruleset_phase, + "ruleset_version": ruleset_version, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.get_zone_entry_point_ruleset_version(**req_copy) + + def test_get_zone_entry_point_ruleset_version_value_error_with_retries(self): + # Enable retries and run test_get_zone_entry_point_ruleset_version_value_error. + _service.enable_retries() + self.test_get_zone_entry_point_ruleset_version_value_error() + + # Disable retries and run test_get_zone_entry_point_ruleset_version_value_error. + _service.disable_retries() + self.test_get_zone_entry_point_ruleset_version_value_error() + + +class TestCreateZoneRulesetRule: + """ + Test Class for create_zone_ruleset_rule + """ + + @responses.activate + def test_create_zone_ruleset_rule_all_params(self): + """ + create_zone_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Set up parameter values + ruleset_id = 'testString' + action = 'testString' + expression = 'ip.src ne 1.1.1.1' + action_parameters = action_parameters_model + ratelimit = ratelimit_model + description = 'testString' + enabled = True + id = 'testString' + logging = logging_model + ref = 'my_ref' + position = position_model + + # Invoke method + response = _service.create_zone_ruleset_rule( + ruleset_id, + action=action, + expression=expression, + action_parameters=action_parameters, + ratelimit=ratelimit, + description=description, + enabled=enabled, + id=id, + logging=logging, + ref=ref, + position=position, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['action'] == 'testString' + assert req_body['expression'] == 'ip.src ne 1.1.1.1' + assert req_body['action_parameters'] == action_parameters_model + assert req_body['ratelimit'] == ratelimit_model + assert req_body['description'] == 'testString' + assert req_body['enabled'] == True + assert req_body['id'] == 'testString' + assert req_body['logging'] == logging_model + assert req_body['ref'] == 'my_ref' + assert req_body['position'] == position_model + + def test_create_zone_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_create_zone_ruleset_rule_all_params. + _service.enable_retries() + self.test_create_zone_ruleset_rule_all_params() + + # Disable retries and run test_create_zone_ruleset_rule_all_params. + _service.disable_retries() + self.test_create_zone_ruleset_rule_all_params() + + @responses.activate + def test_create_zone_ruleset_rule_required_params(self): + """ + test_create_zone_ruleset_rule_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Invoke method + response = _service.create_zone_ruleset_rule( + ruleset_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_create_zone_ruleset_rule_required_params_with_retries(self): + # Enable retries and run test_create_zone_ruleset_rule_required_params. + _service.enable_retries() + self.test_create_zone_ruleset_rule_required_params() + + # Disable retries and run test_create_zone_ruleset_rule_required_params. + _service.disable_retries() + self.test_create_zone_ruleset_rule_required_params() + + @responses.activate + def test_create_zone_ruleset_rule_value_error(self): + """ + test_create_zone_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.POST, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.create_zone_ruleset_rule(**req_copy) + + def test_create_zone_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_create_zone_ruleset_rule_value_error. + _service.enable_retries() + self.test_create_zone_ruleset_rule_value_error() + + # Disable retries and run test_create_zone_ruleset_rule_value_error. + _service.disable_retries() + self.test_create_zone_ruleset_rule_value_error() + + +class TestUpdateZoneRulesetRule: + """ + Test Class for update_zone_ruleset_rule + """ + + @responses.activate + def test_update_zone_ruleset_rule_all_params(self): + """ + update_zone_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Construct a dict representation of a RulesOverride model + rules_override_model = {} + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + # Construct a dict representation of a CategoriesOverride model + categories_override_model = {} + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a dict representation of a Overrides model + overrides_model = {} + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + # Construct a dict representation of a ActionParametersResponse model + action_parameters_response_model = {} + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a dict representation of a ActionParameters model + action_parameters_model = {} + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + # Construct a dict representation of a Ratelimit model + ratelimit_model = {} + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + # Construct a dict representation of a Logging model + logging_model = {} + logging_model['enabled'] = True + + # Construct a dict representation of a Position model + position_model = {} + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + action = 'testString' + action_parameters = action_parameters_model + ratelimit = ratelimit_model + description = 'testString' + enabled = True + expression = 'ip.src ne 1.1.1.1' + id = 'testString' + logging = logging_model + ref = 'my_ref' + position = position_model + + # Invoke method + response = _service.update_zone_ruleset_rule( + ruleset_id, + rule_id, + action=action, + action_parameters=action_parameters, + ratelimit=ratelimit, + description=description, + enabled=enabled, + expression=expression, + id=id, + logging=logging, + ref=ref, + position=position, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + # Validate body params + req_body = json.loads(str(responses.calls[0].request.body, 'utf-8')) + assert req_body['action'] == 'testString' + assert req_body['action_parameters'] == action_parameters_model + assert req_body['ratelimit'] == ratelimit_model + assert req_body['description'] == 'testString' + assert req_body['enabled'] == True + assert req_body['expression'] == 'ip.src ne 1.1.1.1' + assert req_body['id'] == 'testString' + assert req_body['logging'] == logging_model + assert req_body['ref'] == 'my_ref' + assert req_body['position'] == position_model + + def test_update_zone_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_update_zone_ruleset_rule_all_params. + _service.enable_retries() + self.test_update_zone_ruleset_rule_all_params() + + # Disable retries and run test_update_zone_ruleset_rule_all_params. + _service.disable_retries() + self.test_update_zone_ruleset_rule_all_params() + + @responses.activate + def test_update_zone_ruleset_rule_required_params(self): + """ + test_update_zone_ruleset_rule_required_params() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Invoke method + response = _service.update_zone_ruleset_rule( + ruleset_id, + rule_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_update_zone_ruleset_rule_required_params_with_retries(self): + # Enable retries and run test_update_zone_ruleset_rule_required_params. + _service.enable_retries() + self.test_update_zone_ruleset_rule_required_params() + + # Disable retries and run test_update_zone_ruleset_rule_required_params. + _service.disable_retries() + self.test_update_zone_ruleset_rule_required_params() + + @responses.activate + def test_update_zone_ruleset_rule_value_error(self): + """ + test_update_zone_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"description": "Custom instance ruleset", "id": "id", "kind": "managed", "last_updated": "2000-01-01T00:00:00.000000Z", "name": "name", "phase": "ddos_l4", "version": "1", "rules": [{"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}]}}' + responses.add( + responses.PATCH, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "rule_id": rule_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.update_zone_ruleset_rule(**req_copy) + + def test_update_zone_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_update_zone_ruleset_rule_value_error. + _service.enable_retries() + self.test_update_zone_ruleset_rule_value_error() + + # Disable retries and run test_update_zone_ruleset_rule_value_error. + _service.disable_retries() + self.test_update_zone_ruleset_rule_value_error() + + +class TestDeleteZoneRulesetRule: + """ + Test Class for delete_zone_ruleset_rule + """ + + @responses.activate + def test_delete_zone_ruleset_rule_all_params(self): + """ + delete_zone_ruleset_rule() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}}' + responses.add( + responses.DELETE, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Invoke method + response = _service.delete_zone_ruleset_rule( + ruleset_id, + rule_id, + headers={}, + ) + + # Check for correct operation + assert len(responses.calls) == 1 + assert response.status_code == 200 + + def test_delete_zone_ruleset_rule_all_params_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_rule_all_params. + _service.enable_retries() + self.test_delete_zone_ruleset_rule_all_params() + + # Disable retries and run test_delete_zone_ruleset_rule_all_params. + _service.disable_retries() + self.test_delete_zone_ruleset_rule_all_params() + + @responses.activate + def test_delete_zone_ruleset_rule_value_error(self): + """ + test_delete_zone_ruleset_rule_value_error() + """ + # Set up mock + url = preprocess_url('/v1/testString/zones/testString/rulesets/testString/rules/testString') + mock_response = '{"success": true, "errors": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "messages": [{"code": 10000, "message": "something failed in the request", "source": {"pointer": "/rules/0/action"}}], "result": {"id": "id", "version": "version", "action": "action", "action_parameters": {"id": "id", "overrides": {"action": "action", "enabled": false, "sensitivity_level": "high", "rules": [{"id": "id", "enabled": false, "action": "action", "sensitivity_level": "high", "score_threshold": 60}], "categories": [{"category": "category", "enabled": false, "action": "action"}]}, "version": "version", "ruleset": "ruleset", "rulesets": ["rulesets"], "phases": ["phases"], "products": ["products"], "response": {"content": "{\\"success\\": false, \\"error\\": \\"you have been blocked\\"}", "content_type": "application/json", "status_code": 400}}, "categories": ["categories"], "enabled": true, "description": "description", "expression": "ip.src ne 1.1.1.1", "ref": "my_ref", "logging": {"enabled": true}, "last_updated": "2000-01-01T00:00:00.000000Z"}}' + responses.add( + responses.DELETE, + url, + body=mock_response, + content_type='application/json', + status=200, + ) + + # Set up parameter values + ruleset_id = 'testString' + rule_id = 'testString' + + # Pass in all but one required param and check for a ValueError + req_param_dict = { + "ruleset_id": ruleset_id, + "rule_id": rule_id, + } + for param in req_param_dict.keys(): + req_copy = {key: val if key is not param else None for (key, val) in req_param_dict.items()} + with pytest.raises(ValueError): + _service.delete_zone_ruleset_rule(**req_copy) + + def test_delete_zone_ruleset_rule_value_error_with_retries(self): + # Enable retries and run test_delete_zone_ruleset_rule_value_error. + _service.enable_retries() + self.test_delete_zone_ruleset_rule_value_error() + + # Disable retries and run test_delete_zone_ruleset_rule_value_error. + _service.disable_retries() + self.test_delete_zone_ruleset_rule_value_error() + + +# endregion +############################################################################## +# End of Service: ZoneRulesets +############################################################################## + + +############################################################################## +# Start of Model Tests +############################################################################## +# region + + +class TestModel_ActionParametersResponse: + """ + Test Class for ActionParametersResponse + """ + + def test_action_parameters_response_serialization(self): + """ + Test serialization/deserialization for ActionParametersResponse + """ + + # Construct a json representation of a ActionParametersResponse model + action_parameters_response_model_json = {} + action_parameters_response_model_json['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model_json['content_type'] = 'application/json' + action_parameters_response_model_json['status_code'] = 400 + + # Construct a model instance of ActionParametersResponse by calling from_dict on the json representation + action_parameters_response_model = ActionParametersResponse.from_dict(action_parameters_response_model_json) + assert action_parameters_response_model != False + + # Construct a model instance of ActionParametersResponse by calling from_dict on the json representation + action_parameters_response_model_dict = ActionParametersResponse.from_dict(action_parameters_response_model_json).__dict__ + action_parameters_response_model2 = ActionParametersResponse(**action_parameters_response_model_dict) + + # Verify the model instances are equivalent + assert action_parameters_response_model == action_parameters_response_model2 + + # Convert model instance back to dict and verify no loss of data + action_parameters_response_model_json2 = action_parameters_response_model.to_dict() + assert action_parameters_response_model_json2 == action_parameters_response_model_json + + +class TestModel_MessageSource: + """ + Test Class for MessageSource + """ + + def test_message_source_serialization(self): + """ + Test serialization/deserialization for MessageSource + """ + + # Construct a json representation of a MessageSource model + message_source_model_json = {} + message_source_model_json['pointer'] = '/rules/0/action' + + # Construct a model instance of MessageSource by calling from_dict on the json representation + message_source_model = MessageSource.from_dict(message_source_model_json) + assert message_source_model != False + + # Construct a model instance of MessageSource by calling from_dict on the json representation + message_source_model_dict = MessageSource.from_dict(message_source_model_json).__dict__ + message_source_model2 = MessageSource(**message_source_model_dict) + + # Verify the model instances are equivalent + assert message_source_model == message_source_model2 + + # Convert model instance back to dict and verify no loss of data + message_source_model_json2 = message_source_model.to_dict() + assert message_source_model_json2 == message_source_model_json + + +class TestModel_ActionParameters: + """ + Test Class for ActionParameters + """ + + def test_action_parameters_serialization(self): + """ + Test serialization/deserialization for ActionParameters + """ + + # Construct dict forms of any model objects needed in order to build this model. + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + # Construct a json representation of a ActionParameters model + action_parameters_model_json = {} + action_parameters_model_json['id'] = 'testString' + action_parameters_model_json['overrides'] = overrides_model + action_parameters_model_json['version'] = 'testString' + action_parameters_model_json['ruleset'] = 'testString' + action_parameters_model_json['rulesets'] = ['testString'] + action_parameters_model_json['phases'] = ['testString'] + action_parameters_model_json['products'] = ['testString'] + action_parameters_model_json['response'] = action_parameters_response_model + + # Construct a model instance of ActionParameters by calling from_dict on the json representation + action_parameters_model = ActionParameters.from_dict(action_parameters_model_json) + assert action_parameters_model != False + + # Construct a model instance of ActionParameters by calling from_dict on the json representation + action_parameters_model_dict = ActionParameters.from_dict(action_parameters_model_json).__dict__ + action_parameters_model2 = ActionParameters(**action_parameters_model_dict) + + # Verify the model instances are equivalent + assert action_parameters_model == action_parameters_model2 + + # Convert model instance back to dict and verify no loss of data + action_parameters_model_json2 = action_parameters_model.to_dict() + assert action_parameters_model_json2 == action_parameters_model_json + + +class TestModel_CategoriesOverride: + """ + Test Class for CategoriesOverride + """ + + def test_categories_override_serialization(self): + """ + Test serialization/deserialization for CategoriesOverride + """ + + # Construct a json representation of a CategoriesOverride model + categories_override_model_json = {} + categories_override_model_json['category'] = 'testString' + categories_override_model_json['enabled'] = True + categories_override_model_json['action'] = 'testString' + + # Construct a model instance of CategoriesOverride by calling from_dict on the json representation + categories_override_model = CategoriesOverride.from_dict(categories_override_model_json) + assert categories_override_model != False + + # Construct a model instance of CategoriesOverride by calling from_dict on the json representation + categories_override_model_dict = CategoriesOverride.from_dict(categories_override_model_json).__dict__ + categories_override_model2 = CategoriesOverride(**categories_override_model_dict) + + # Verify the model instances are equivalent + assert categories_override_model == categories_override_model2 + + # Convert model instance back to dict and verify no loss of data + categories_override_model_json2 = categories_override_model.to_dict() + assert categories_override_model_json2 == categories_override_model_json + + +class TestModel_ListRulesetsResp: + """ + Test Class for ListRulesetsResp + """ + + def test_list_rulesets_resp_serialization(self): + """ + Test serialization/deserialization for ListRulesetsResp + """ + + # Construct dict forms of any model objects needed in order to build this model. + + message_source_model = {} # MessageSource + message_source_model['pointer'] = '/rules/0/action' + + message_model = {} # Message + message_model['code'] = 10000 + message_model['message'] = 'something failed in the request' + message_model['source'] = message_source_model + + listed_ruleset_model = {} # ListedRuleset + listed_ruleset_model['description'] = 'Custom instance ruleset' + listed_ruleset_model['id'] = 'testString' + listed_ruleset_model['kind'] = 'managed' + listed_ruleset_model['last_updated'] = '2000-01-01T00:00:00.000000Z' + listed_ruleset_model['name'] = 'testString' + listed_ruleset_model['phase'] = 'ddos_l4' + listed_ruleset_model['version'] = '1' + + # Construct a json representation of a ListRulesetsResp model + list_rulesets_resp_model_json = {} + list_rulesets_resp_model_json['success'] = True + list_rulesets_resp_model_json['errors'] = [message_model] + list_rulesets_resp_model_json['messages'] = [message_model] + list_rulesets_resp_model_json['result'] = [listed_ruleset_model] + + # Construct a model instance of ListRulesetsResp by calling from_dict on the json representation + list_rulesets_resp_model = ListRulesetsResp.from_dict(list_rulesets_resp_model_json) + assert list_rulesets_resp_model != False + + # Construct a model instance of ListRulesetsResp by calling from_dict on the json representation + list_rulesets_resp_model_dict = ListRulesetsResp.from_dict(list_rulesets_resp_model_json).__dict__ + list_rulesets_resp_model2 = ListRulesetsResp(**list_rulesets_resp_model_dict) + + # Verify the model instances are equivalent + assert list_rulesets_resp_model == list_rulesets_resp_model2 + + # Convert model instance back to dict and verify no loss of data + list_rulesets_resp_model_json2 = list_rulesets_resp_model.to_dict() + assert list_rulesets_resp_model_json2 == list_rulesets_resp_model_json + + +class TestModel_ListedRuleset: + """ + Test Class for ListedRuleset + """ + + def test_listed_ruleset_serialization(self): + """ + Test serialization/deserialization for ListedRuleset + """ + + # Construct a json representation of a ListedRuleset model + listed_ruleset_model_json = {} + listed_ruleset_model_json['description'] = 'Custom instance ruleset' + listed_ruleset_model_json['id'] = 'testString' + listed_ruleset_model_json['kind'] = 'managed' + listed_ruleset_model_json['last_updated'] = '2000-01-01T00:00:00.000000Z' + listed_ruleset_model_json['name'] = 'testString' + listed_ruleset_model_json['phase'] = 'ddos_l4' + listed_ruleset_model_json['version'] = '1' + + # Construct a model instance of ListedRuleset by calling from_dict on the json representation + listed_ruleset_model = ListedRuleset.from_dict(listed_ruleset_model_json) + assert listed_ruleset_model != False + + # Construct a model instance of ListedRuleset by calling from_dict on the json representation + listed_ruleset_model_dict = ListedRuleset.from_dict(listed_ruleset_model_json).__dict__ + listed_ruleset_model2 = ListedRuleset(**listed_ruleset_model_dict) + + # Verify the model instances are equivalent + assert listed_ruleset_model == listed_ruleset_model2 + + # Convert model instance back to dict and verify no loss of data + listed_ruleset_model_json2 = listed_ruleset_model.to_dict() + assert listed_ruleset_model_json2 == listed_ruleset_model_json + + +class TestModel_Logging: + """ + Test Class for Logging + """ + + def test_logging_serialization(self): + """ + Test serialization/deserialization for Logging + """ + + # Construct a json representation of a Logging model + logging_model_json = {} + logging_model_json['enabled'] = True + + # Construct a model instance of Logging by calling from_dict on the json representation + logging_model = Logging.from_dict(logging_model_json) + assert logging_model != False + + # Construct a model instance of Logging by calling from_dict on the json representation + logging_model_dict = Logging.from_dict(logging_model_json).__dict__ + logging_model2 = Logging(**logging_model_dict) + + # Verify the model instances are equivalent + assert logging_model == logging_model2 + + # Convert model instance back to dict and verify no loss of data + logging_model_json2 = logging_model.to_dict() + assert logging_model_json2 == logging_model_json + + +class TestModel_Message: + """ + Test Class for Message + """ + + def test_message_serialization(self): + """ + Test serialization/deserialization for Message + """ + + # Construct dict forms of any model objects needed in order to build this model. + + message_source_model = {} # MessageSource + message_source_model['pointer'] = '/rules/0/action' + + # Construct a json representation of a Message model + message_model_json = {} + message_model_json['code'] = 10000 + message_model_json['message'] = 'something failed in the request' + message_model_json['source'] = message_source_model + + # Construct a model instance of Message by calling from_dict on the json representation + message_model = Message.from_dict(message_model_json) + assert message_model != False + + # Construct a model instance of Message by calling from_dict on the json representation + message_model_dict = Message.from_dict(message_model_json).__dict__ + message_model2 = Message(**message_model_dict) + + # Verify the model instances are equivalent + assert message_model == message_model2 + + # Convert model instance back to dict and verify no loss of data + message_model_json2 = message_model.to_dict() + assert message_model_json2 == message_model_json + + +class TestModel_Overrides: + """ + Test Class for Overrides + """ + + def test_overrides_serialization(self): + """ + Test serialization/deserialization for Overrides + """ + + # Construct dict forms of any model objects needed in order to build this model. + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + # Construct a json representation of a Overrides model + overrides_model_json = {} + overrides_model_json['action'] = 'testString' + overrides_model_json['enabled'] = True + overrides_model_json['sensitivity_level'] = 'high' + overrides_model_json['rules'] = [rules_override_model] + overrides_model_json['categories'] = [categories_override_model] + + # Construct a model instance of Overrides by calling from_dict on the json representation + overrides_model = Overrides.from_dict(overrides_model_json) + assert overrides_model != False + + # Construct a model instance of Overrides by calling from_dict on the json representation + overrides_model_dict = Overrides.from_dict(overrides_model_json).__dict__ + overrides_model2 = Overrides(**overrides_model_dict) + + # Verify the model instances are equivalent + assert overrides_model == overrides_model2 + + # Convert model instance back to dict and verify no loss of data + overrides_model_json2 = overrides_model.to_dict() + assert overrides_model_json2 == overrides_model_json + + +class TestModel_Position: + """ + Test Class for Position + """ + + def test_position_serialization(self): + """ + Test serialization/deserialization for Position + """ + + # Construct a json representation of a Position model + position_model_json = {} + position_model_json['before'] = 'testString' + position_model_json['after'] = 'testString' + position_model_json['index'] = 0 + + # Construct a model instance of Position by calling from_dict on the json representation + position_model = Position.from_dict(position_model_json) + assert position_model != False + + # Construct a model instance of Position by calling from_dict on the json representation + position_model_dict = Position.from_dict(position_model_json).__dict__ + position_model2 = Position(**position_model_dict) + + # Verify the model instances are equivalent + assert position_model == position_model2 + + # Convert model instance back to dict and verify no loss of data + position_model_json2 = position_model.to_dict() + assert position_model_json2 == position_model_json + + +class TestModel_Ratelimit: + """ + Test Class for Ratelimit + """ + + def test_ratelimit_serialization(self): + """ + Test serialization/deserialization for Ratelimit + """ + + # Construct a json representation of a Ratelimit model + ratelimit_model_json = {} + ratelimit_model_json['characteristics'] = ['testString'] + ratelimit_model_json['counting_expression'] = 'testString' + ratelimit_model_json['mitigation_timeout'] = 38 + ratelimit_model_json['period'] = 38 + ratelimit_model_json['requests_per_period'] = 38 + + # Construct a model instance of Ratelimit by calling from_dict on the json representation + ratelimit_model = Ratelimit.from_dict(ratelimit_model_json) + assert ratelimit_model != False + + # Construct a model instance of Ratelimit by calling from_dict on the json representation + ratelimit_model_dict = Ratelimit.from_dict(ratelimit_model_json).__dict__ + ratelimit_model2 = Ratelimit(**ratelimit_model_dict) + + # Verify the model instances are equivalent + assert ratelimit_model == ratelimit_model2 + + # Convert model instance back to dict and verify no loss of data + ratelimit_model_json2 = ratelimit_model.to_dict() + assert ratelimit_model_json2 == ratelimit_model_json + + +class TestModel_RuleCreate: + """ + Test Class for RuleCreate + """ + + def test_rule_create_serialization(self): + """ + Test serialization/deserialization for RuleCreate + """ + + # Construct dict forms of any model objects needed in order to build this model. + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + action_parameters_model = {} # ActionParameters + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + ratelimit_model = {} # Ratelimit + ratelimit_model['characteristics'] = ['testString'] + ratelimit_model['counting_expression'] = 'testString' + ratelimit_model['mitigation_timeout'] = 38 + ratelimit_model['period'] = 38 + ratelimit_model['requests_per_period'] = 38 + + logging_model = {} # Logging + logging_model['enabled'] = True + + position_model = {} # Position + position_model['before'] = 'testString' + position_model['after'] = 'testString' + position_model['index'] = 0 + + # Construct a json representation of a RuleCreate model + rule_create_model_json = {} + rule_create_model_json['action'] = 'testString' + rule_create_model_json['action_parameters'] = action_parameters_model + rule_create_model_json['ratelimit'] = ratelimit_model + rule_create_model_json['description'] = 'testString' + rule_create_model_json['enabled'] = True + rule_create_model_json['expression'] = 'ip.src ne 1.1.1.1' + rule_create_model_json['id'] = 'testString' + rule_create_model_json['logging'] = logging_model + rule_create_model_json['ref'] = 'my_ref' + rule_create_model_json['position'] = position_model + + # Construct a model instance of RuleCreate by calling from_dict on the json representation + rule_create_model = RuleCreate.from_dict(rule_create_model_json) + assert rule_create_model != False + + # Construct a model instance of RuleCreate by calling from_dict on the json representation + rule_create_model_dict = RuleCreate.from_dict(rule_create_model_json).__dict__ + rule_create_model2 = RuleCreate(**rule_create_model_dict) + + # Verify the model instances are equivalent + assert rule_create_model == rule_create_model2 + + # Convert model instance back to dict and verify no loss of data + rule_create_model_json2 = rule_create_model.to_dict() + assert rule_create_model_json2 == rule_create_model_json + + +class TestModel_RuleDetails: + """ + Test Class for RuleDetails + """ + + def test_rule_details_serialization(self): + """ + Test serialization/deserialization for RuleDetails + """ + + # Construct dict forms of any model objects needed in order to build this model. + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + action_parameters_model = {} # ActionParameters + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + logging_model = {} # Logging + logging_model['enabled'] = True + + # Construct a json representation of a RuleDetails model + rule_details_model_json = {} + rule_details_model_json['id'] = 'testString' + rule_details_model_json['version'] = 'testString' + rule_details_model_json['action'] = 'testString' + rule_details_model_json['action_parameters'] = action_parameters_model + rule_details_model_json['categories'] = ['testString'] + rule_details_model_json['enabled'] = True + rule_details_model_json['description'] = 'testString' + rule_details_model_json['expression'] = 'ip.src ne 1.1.1.1' + rule_details_model_json['ref'] = 'my_ref' + rule_details_model_json['logging'] = logging_model + rule_details_model_json['last_updated'] = '2000-01-01T00:00:00.000000Z' + + # Construct a model instance of RuleDetails by calling from_dict on the json representation + rule_details_model = RuleDetails.from_dict(rule_details_model_json) + assert rule_details_model != False + + # Construct a model instance of RuleDetails by calling from_dict on the json representation + rule_details_model_dict = RuleDetails.from_dict(rule_details_model_json).__dict__ + rule_details_model2 = RuleDetails(**rule_details_model_dict) + + # Verify the model instances are equivalent + assert rule_details_model == rule_details_model2 + + # Convert model instance back to dict and verify no loss of data + rule_details_model_json2 = rule_details_model.to_dict() + assert rule_details_model_json2 == rule_details_model_json + + +class TestModel_RuleResp: + """ + Test Class for RuleResp + """ + + def test_rule_resp_serialization(self): + """ + Test serialization/deserialization for RuleResp + """ + + # Construct dict forms of any model objects needed in order to build this model. + + message_source_model = {} # MessageSource + message_source_model['pointer'] = '/rules/0/action' + + message_model = {} # Message + message_model['code'] = 10000 + message_model['message'] = 'something failed in the request' + message_model['source'] = message_source_model + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + action_parameters_model = {} # ActionParameters + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + logging_model = {} # Logging + logging_model['enabled'] = True + + rule_details_model = {} # RuleDetails + rule_details_model['id'] = 'testString' + rule_details_model['version'] = 'testString' + rule_details_model['action'] = 'testString' + rule_details_model['action_parameters'] = action_parameters_model + rule_details_model['categories'] = ['testString'] + rule_details_model['enabled'] = True + rule_details_model['description'] = 'testString' + rule_details_model['expression'] = 'ip.src ne 1.1.1.1' + rule_details_model['ref'] = 'my_ref' + rule_details_model['logging'] = logging_model + rule_details_model['last_updated'] = '2000-01-01T00:00:00.000000Z' + + # Construct a json representation of a RuleResp model + rule_resp_model_json = {} + rule_resp_model_json['success'] = True + rule_resp_model_json['errors'] = [message_model] + rule_resp_model_json['messages'] = [message_model] + rule_resp_model_json['result'] = rule_details_model + + # Construct a model instance of RuleResp by calling from_dict on the json representation + rule_resp_model = RuleResp.from_dict(rule_resp_model_json) + assert rule_resp_model != False + + # Construct a model instance of RuleResp by calling from_dict on the json representation + rule_resp_model_dict = RuleResp.from_dict(rule_resp_model_json).__dict__ + rule_resp_model2 = RuleResp(**rule_resp_model_dict) + + # Verify the model instances are equivalent + assert rule_resp_model == rule_resp_model2 + + # Convert model instance back to dict and verify no loss of data + rule_resp_model_json2 = rule_resp_model.to_dict() + assert rule_resp_model_json2 == rule_resp_model_json + + +class TestModel_RulesOverride: + """ + Test Class for RulesOverride + """ + + def test_rules_override_serialization(self): + """ + Test serialization/deserialization for RulesOverride + """ + + # Construct a json representation of a RulesOverride model + rules_override_model_json = {} + rules_override_model_json['id'] = 'testString' + rules_override_model_json['enabled'] = True + rules_override_model_json['action'] = 'testString' + rules_override_model_json['sensitivity_level'] = 'high' + rules_override_model_json['score_threshold'] = 60 + + # Construct a model instance of RulesOverride by calling from_dict on the json representation + rules_override_model = RulesOverride.from_dict(rules_override_model_json) + assert rules_override_model != False + + # Construct a model instance of RulesOverride by calling from_dict on the json representation + rules_override_model_dict = RulesOverride.from_dict(rules_override_model_json).__dict__ + rules_override_model2 = RulesOverride(**rules_override_model_dict) + + # Verify the model instances are equivalent + assert rules_override_model == rules_override_model2 + + # Convert model instance back to dict and verify no loss of data + rules_override_model_json2 = rules_override_model.to_dict() + assert rules_override_model_json2 == rules_override_model_json + + +class TestModel_RulesetDetails: + """ + Test Class for RulesetDetails + """ + + def test_ruleset_details_serialization(self): + """ + Test serialization/deserialization for RulesetDetails + """ + + # Construct dict forms of any model objects needed in order to build this model. + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + action_parameters_model = {} # ActionParameters + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + logging_model = {} # Logging + logging_model['enabled'] = True + + rule_details_model = {} # RuleDetails + rule_details_model['id'] = 'testString' + rule_details_model['version'] = 'testString' + rule_details_model['action'] = 'testString' + rule_details_model['action_parameters'] = action_parameters_model + rule_details_model['categories'] = ['testString'] + rule_details_model['enabled'] = True + rule_details_model['description'] = 'testString' + rule_details_model['expression'] = 'ip.src ne 1.1.1.1' + rule_details_model['ref'] = 'my_ref' + rule_details_model['logging'] = logging_model + rule_details_model['last_updated'] = '2000-01-01T00:00:00.000000Z' + + # Construct a json representation of a RulesetDetails model + ruleset_details_model_json = {} + ruleset_details_model_json['description'] = 'Custom instance ruleset' + ruleset_details_model_json['id'] = 'testString' + ruleset_details_model_json['kind'] = 'managed' + ruleset_details_model_json['last_updated'] = '2000-01-01T00:00:00.000000Z' + ruleset_details_model_json['name'] = 'testString' + ruleset_details_model_json['phase'] = 'ddos_l4' + ruleset_details_model_json['version'] = '1' + ruleset_details_model_json['rules'] = [rule_details_model] + + # Construct a model instance of RulesetDetails by calling from_dict on the json representation + ruleset_details_model = RulesetDetails.from_dict(ruleset_details_model_json) + assert ruleset_details_model != False + + # Construct a model instance of RulesetDetails by calling from_dict on the json representation + ruleset_details_model_dict = RulesetDetails.from_dict(ruleset_details_model_json).__dict__ + ruleset_details_model2 = RulesetDetails(**ruleset_details_model_dict) + + # Verify the model instances are equivalent + assert ruleset_details_model == ruleset_details_model2 + + # Convert model instance back to dict and verify no loss of data + ruleset_details_model_json2 = ruleset_details_model.to_dict() + assert ruleset_details_model_json2 == ruleset_details_model_json + + +class TestModel_RulesetResp: + """ + Test Class for RulesetResp + """ + + def test_ruleset_resp_serialization(self): + """ + Test serialization/deserialization for RulesetResp + """ + + # Construct dict forms of any model objects needed in order to build this model. + + message_source_model = {} # MessageSource + message_source_model['pointer'] = '/rules/0/action' + + message_model = {} # Message + message_model['code'] = 10000 + message_model['message'] = 'something failed in the request' + message_model['source'] = message_source_model + + rules_override_model = {} # RulesOverride + rules_override_model['id'] = 'testString' + rules_override_model['enabled'] = True + rules_override_model['action'] = 'testString' + rules_override_model['sensitivity_level'] = 'high' + rules_override_model['score_threshold'] = 60 + + categories_override_model = {} # CategoriesOverride + categories_override_model['category'] = 'testString' + categories_override_model['enabled'] = True + categories_override_model['action'] = 'testString' + + overrides_model = {} # Overrides + overrides_model['action'] = 'testString' + overrides_model['enabled'] = True + overrides_model['sensitivity_level'] = 'high' + overrides_model['rules'] = [rules_override_model] + overrides_model['categories'] = [categories_override_model] + + action_parameters_response_model = {} # ActionParametersResponse + action_parameters_response_model['content'] = '{"success": false, "error": "you have been blocked"}' + action_parameters_response_model['content_type'] = 'application/json' + action_parameters_response_model['status_code'] = 400 + + action_parameters_model = {} # ActionParameters + action_parameters_model['id'] = 'testString' + action_parameters_model['overrides'] = overrides_model + action_parameters_model['version'] = 'testString' + action_parameters_model['ruleset'] = 'testString' + action_parameters_model['rulesets'] = ['testString'] + action_parameters_model['phases'] = ['testString'] + action_parameters_model['products'] = ['testString'] + action_parameters_model['response'] = action_parameters_response_model + + logging_model = {} # Logging + logging_model['enabled'] = True + + rule_details_model = {} # RuleDetails + rule_details_model['id'] = 'testString' + rule_details_model['version'] = 'testString' + rule_details_model['action'] = 'testString' + rule_details_model['action_parameters'] = action_parameters_model + rule_details_model['categories'] = ['testString'] + rule_details_model['enabled'] = True + rule_details_model['description'] = 'testString' + rule_details_model['expression'] = 'ip.src ne 1.1.1.1' + rule_details_model['ref'] = 'my_ref' + rule_details_model['logging'] = logging_model + rule_details_model['last_updated'] = '2000-01-01T00:00:00.000000Z' + + ruleset_details_model = {} # RulesetDetails + ruleset_details_model['description'] = 'Custom instance ruleset' + ruleset_details_model['id'] = 'testString' + ruleset_details_model['kind'] = 'managed' + ruleset_details_model['last_updated'] = '2000-01-01T00:00:00.000000Z' + ruleset_details_model['name'] = 'testString' + ruleset_details_model['phase'] = 'ddos_l4' + ruleset_details_model['version'] = '1' + ruleset_details_model['rules'] = [rule_details_model] + + # Construct a json representation of a RulesetResp model + ruleset_resp_model_json = {} + ruleset_resp_model_json['success'] = True + ruleset_resp_model_json['errors'] = [message_model] + ruleset_resp_model_json['messages'] = [message_model] + ruleset_resp_model_json['result'] = ruleset_details_model + + # Construct a model instance of RulesetResp by calling from_dict on the json representation + ruleset_resp_model = RulesetResp.from_dict(ruleset_resp_model_json) + assert ruleset_resp_model != False + + # Construct a model instance of RulesetResp by calling from_dict on the json representation + ruleset_resp_model_dict = RulesetResp.from_dict(ruleset_resp_model_json).__dict__ + ruleset_resp_model2 = RulesetResp(**ruleset_resp_model_dict) + + # Verify the model instances are equivalent + assert ruleset_resp_model == ruleset_resp_model2 + + # Convert model instance back to dict and verify no loss of data + ruleset_resp_model_json2 = ruleset_resp_model.to_dict() + assert ruleset_resp_model_json2 == ruleset_resp_model_json + + +# endregion +############################################################################## +# End of Model Tests +############################################################################## \ No newline at end of file