diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 70f7784c1..6f689dc89 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -35,6 +35,23 @@ jobs: with: python-version: ${{ matrix.python-version }} + mypy: + name: Check type hints + runs-on: "ubuntu-latest" + strategy: + matrix: + python-version: + - "3.9" + - "3.10" + - "3.11" + - "3.12" + steps: + - uses: actions/checkout@v4 + - name: Run mypy + uses: greenbone/actions/mypy-python@v3 + with: + python-version: ${{ matrix.python-version }} + codecov: name: Upload coverage to codecov.io needs: test diff --git a/docs/api/connections.rst b/docs/api/connections.rst index 305b8b95f..97af68a54 100644 --- a/docs/api/connections.rst +++ b/docs/api/connections.rst @@ -10,15 +10,12 @@ Connections .. autoclass:: SSHConnection :members: - :inherited-members: .. autoclass:: TLSConnection :members: - :inherited-members: .. autoclass:: UnixSocketConnection :members: - :inherited-members: .. autoclass:: DebugConnection :members: diff --git a/docs/api/gmp.rst b/docs/api/gmp.rst index 625bf2611..851383ee6 100644 --- a/docs/api/gmp.rst +++ b/docs/api/gmp.rst @@ -1,15 +1,15 @@ .. _gmp: -.. avoid TOCtree warning by marking this file as orphan - -:orphan: GMP ^^^ .. automodule:: gvm.protocols.gmp -Protocol --------- - -.. autoclass:: Gmp +.. autoclass:: GMP :members: + +.. toctree:: + :maxdepth: 1 + + gmpv224 + gmpv225 diff --git a/docs/api/gmpv208.rst b/docs/api/gmpv208.rst deleted file mode 100644 index a6a9c1832..000000000 --- a/docs/api/gmpv208.rst +++ /dev/null @@ -1,116 +0,0 @@ -.. _gmpv208: - -GMP v20.8 -^^^^^^^^^ - -.. automodule:: gvm.protocols.gmpv208 - -Enums ------ - -.. autoclass:: AlertCondition - :members: - :undoc-members: - :noindex: - -.. autoclass:: AlertEvent - :members: - :undoc-members: - :noindex: - -.. autoclass:: AlertMethod - :members: - :undoc-members: - :noindex: - -.. autoclass:: AliveTest - :members: - :undoc-members: - :noindex: - -.. autoclass:: CredentialFormat - :members: - :undoc-members: - :noindex: - -.. autoclass:: CredentialType - :members: - :undoc-members: - :noindex: - -.. autoclass:: EntityType - :members: - :undoc-members: - :noindex: - -.. autoclass:: FeedType - :members: - :undoc-members: - :noindex: - -.. autoclass:: FilterType - :members: - :undoc-members: - :noindex: - -.. autoclass:: HelpFormat - :members: - :undoc-members: - :noindex: - -.. autoclass:: HostsOrdering - :members: - :undoc-members: - :noindex: - -.. autoclass:: InfoType - :members: - :undoc-members: - :noindex: - -.. autoclass:: PermissionSubjectType - :members: - :undoc-members: - :noindex: - -.. autoclass:: PortRangeType - :members: - :undoc-members: - :noindex: - -.. autoclass:: ReportFormatType - :members: - :undoc-members: - :noindex: - -.. autoclass:: ScannerType - :members: - :undoc-members: - :noindex: - -.. autoclass:: SeverityLevel - :members: - :undoc-members: - :noindex: - -.. autoclass:: SnmpAuthAlgorithm - :members: - :undoc-members: - :noindex: - -.. autoclass:: SnmpPrivacyAlgorithm - :members: - :undoc-members: - :noindex: - -.. autoclass:: TicketStatus - :members: - :undoc-members: - :noindex: - -Protocol --------- - -.. autoclass:: Gmp - :members: - :inherited-members: diff --git a/docs/api/gmpv214.rst b/docs/api/gmpv214.rst deleted file mode 100644 index 267f69700..000000000 --- a/docs/api/gmpv214.rst +++ /dev/null @@ -1,116 +0,0 @@ -.. _gmpv214: - -GMP v21.4 -^^^^^^^^^ - -.. automodule:: gvm.protocols.gmpv214 - -Enums ------ - -.. autoclass:: AlertCondition - :members: - :undoc-members: - :noindex: - -.. autoclass:: AlertEvent - :members: - :undoc-members: - :noindex: - -.. autoclass:: AlertMethod - :members: - :undoc-members: - :noindex: - -.. autoclass:: AliveTest - :members: - :undoc-members: - :noindex: - -.. autoclass:: CredentialFormat - :members: - :undoc-members: - :noindex: - -.. autoclass:: CredentialType - :members: - :undoc-members: - :noindex: - -.. autoclass:: EntityType - :members: - :undoc-members: - :noindex: - -.. autoclass:: FeedType - :members: - :undoc-members: - :noindex: - -.. autoclass:: FilterType - :members: - :undoc-members: - :noindex: - -.. autoclass:: HostsOrdering - :members: - :undoc-members: - :noindex: - -.. autoclass:: HelpFormat - :members: - :undoc-members: - :noindex: - -.. autoclass:: InfoType - :members: - :undoc-members: - :noindex: - -.. autoclass:: PermissionSubjectType - :members: - :undoc-members: - :noindex: - -.. autoclass:: PortRangeType - :members: - :undoc-members: - :noindex: - -.. autoclass:: ReportFormatType - :members: - :undoc-members: - :noindex: - -.. autoclass:: ScannerType - :members: - :undoc-members: - :noindex: - -.. autoclass:: SeverityLevel - :members: - :undoc-members: - :noindex: - -.. autoclass:: SnmpAuthAlgorithm - :members: - :undoc-members: - :noindex: - -.. autoclass:: SnmpPrivacyAlgorithm - :members: - :undoc-members: - :noindex: - -.. autoclass:: TicketStatus - :members: - :undoc-members: - :noindex: - -Protocol --------- - -.. autoclass:: Gmp - :members: - :inherited-members: diff --git a/docs/api/gmpv224.rst b/docs/api/gmpv224.rst index e3f4415f4..57183d621 100644 --- a/docs/api/gmpv224.rst +++ b/docs/api/gmpv224.rst @@ -3,114 +3,91 @@ GMP v22.4 ^^^^^^^^^ -.. automodule:: gvm.protocols.gmpv224 +.. automodule:: gvm.protocols.gmp._gmp224 -Enums ------ -.. autoclass:: AlertCondition - :members: - :undoc-members: - :noindex: +Protocol +-------- -.. autoclass:: AlertEvent +.. autoclass:: gvm.protocols.gmp.GMPv224 :members: - :undoc-members: - :noindex: + :inherited-members: -.. autoclass:: AlertMethod +Enums +----- + +.. autoclass:: gvm.protocols.gmp.requests.v224.AlertCondition :members: :undoc-members: - :noindex: -.. autoclass:: AliveTest +.. autoclass:: gvm.protocols.gmp.requests.v224.AlertEvent :members: :undoc-members: - :noindex: -.. autoclass:: CredentialFormat +.. autoclass:: gvm.protocols.gmp.requests.v224.AlertMethod :members: :undoc-members: - :noindex: -.. autoclass:: CredentialType +.. autoclass:: gvm.protocols.gmp.requests.v224.AliveTest :members: :undoc-members: - :noindex: -.. autoclass:: EntityType +.. autoclass:: gvm.protocols.gmp.requests.v224.CredentialFormat :members: :undoc-members: - :noindex: -.. autoclass:: FeedType +.. autoclass:: gvm.protocols.gmp.requests.v224.CredentialType :members: :undoc-members: - :noindex: -.. autoclass:: FilterType +.. autoclass:: gvm.protocols.gmp.requests.v224.EntityType :members: :undoc-members: - :noindex: -.. autoclass:: HostsOrdering +.. autoclass:: gvm.protocols.gmp.requests.v224.FeedType :members: :undoc-members: - :noindex: -.. autoclass:: HelpFormat +.. autoclass:: gvm.protocols.gmp.requests.v224.FilterType :members: :undoc-members: - :noindex: -.. autoclass:: InfoType +.. autoclass:: gvm.protocols.gmp.requests.v224.HostsOrdering :members: :undoc-members: - :noindex: -.. autoclass:: PermissionSubjectType +.. autoclass:: gvm.protocols.gmp.requests.v224.HelpFormat :members: :undoc-members: - :noindex: -.. autoclass:: PortRangeType +.. autoclass:: gvm.protocols.gmp.requests.v224.InfoType :members: :undoc-members: - :noindex: -.. autoclass:: ReportFormatType +.. autoclass:: gvm.protocols.gmp.requests.v224.PermissionSubjectType :members: :undoc-members: - :noindex: -.. autoclass:: ScannerType +.. autoclass:: gvm.protocols.gmp.requests.v224.PortRangeType :members: :undoc-members: - :noindex: -.. autoclass:: SeverityLevel +.. autoclass:: gvm.protocols.gmp.requests.v224.ReportFormatType :members: :undoc-members: - :noindex: -.. autoclass:: SnmpAuthAlgorithm +.. autoclass:: gvm.protocols.gmp.requests.v224.ScannerType :members: :undoc-members: - :noindex: -.. autoclass:: SnmpPrivacyAlgorithm +.. autoclass:: gvm.protocols.gmp.requests.v224.SnmpAuthAlgorithm :members: :undoc-members: - :noindex: -.. autoclass:: TicketStatus +.. autoclass:: gvm.protocols.gmp.requests.v224.SnmpPrivacyAlgorithm :members: :undoc-members: - :noindex: - -Protocol --------- -.. autoclass:: Gmp +.. autoclass:: gvm.protocols.gmp.requests.v224.TicketStatus :members: - :inherited-members: + :undoc-members: diff --git a/docs/api/gmpv225.rst b/docs/api/gmpv225.rst index b1d5c2015..34d1f717c 100644 --- a/docs/api/gmpv225.rst +++ b/docs/api/gmpv225.rst @@ -3,98 +3,113 @@ GMP v22.5 ^^^^^^^^^ -.. automodule:: gvm.protocols.gmpv225 +.. automodule:: gvm.protocols.gmp._gmp225 -Enums ------ +Protocol +-------- -.. autoclass:: AlertCondition +.. autoclass:: gvm.protocols.gmp.GMPv225 :members: - :undoc-members: + :inherited-members: -.. autoclass:: AlertEvent - :members: - :undoc-members: +Enums +----- -.. autoclass:: AlertMethod +.. autoclass:: gvm.protocols.gmp.requests.v225.AlertCondition :members: :undoc-members: + :no-index: -.. autoclass:: AliveTest +.. autoclass:: gvm.protocols.gmp.requests.v225.AlertEvent :members: :undoc-members: + :no-index: -.. autoclass:: CredentialFormat +.. autoclass:: gvm.protocols.gmp.requests.v225.AlertMethod :members: :undoc-members: + :no-index: -.. autoclass:: CredentialType +.. autoclass:: gvm.protocols.gmp.requests.v225.AliveTest :members: :undoc-members: + :no-index: -.. autoclass:: EntityType +.. autoclass:: gvm.protocols.gmp.requests.v225.CredentialFormat :members: :undoc-members: + :no-index: -.. autoclass:: FeedType +.. autoclass:: gvm.protocols.gmp.requests.v225.CredentialType :members: :undoc-members: + :no-index: -.. autoclass:: FilterType +.. autoclass:: gvm.protocols.gmp.requests.v225.EntityType :members: :undoc-members: + :no-index: -.. autoclass:: HostsOrdering +.. autoclass:: gvm.protocols.gmp.requests.v225.FeedType :members: :undoc-members: + :no-index: -.. autoclass:: HelpFormat +.. autoclass:: gvm.protocols.gmp.requests.v225.FilterType :members: :undoc-members: + :no-index: -.. autoclass:: InfoType +.. autoclass:: gvm.protocols.gmp.requests.v225.HostsOrdering :members: :undoc-members: + :no-index: -.. autoclass:: PermissionSubjectType +.. autoclass:: gvm.protocols.gmp.requests.v225.HelpFormat :members: :undoc-members: + :no-index: -.. autoclass:: PortRangeType +.. autoclass:: gvm.protocols.gmp.requests.v225.InfoType :members: :undoc-members: + :no-index: -.. autoclass:: ReportFormatType +.. autoclass:: gvm.protocols.gmp.requests.v225.PermissionSubjectType :members: :undoc-members: + :no-index: -.. autoclass:: ResourceType +.. autoclass:: gvm.protocols.gmp.requests.v225.PortRangeType :members: :undoc-members: + :no-index: -.. autoclass:: ScannerType +.. autoclass:: gvm.protocols.gmp.requests.v225.ReportFormatType :members: :undoc-members: + :no-index: -.. autoclass:: SeverityLevel +.. autoclass:: gvm.protocols.gmp.requests.v225.ResourceType :members: :undoc-members: -.. autoclass:: SnmpAuthAlgorithm +.. autoclass:: gvm.protocols.gmp.requests.v225.ScannerType :members: :undoc-members: + :no-index: -.. autoclass:: SnmpPrivacyAlgorithm +.. autoclass:: gvm.protocols.gmp.requests.v225.SnmpAuthAlgorithm :members: :undoc-members: + :no-index: -.. autoclass:: TicketStatus +.. autoclass:: gvm.protocols.gmp.requests.v225.SnmpPrivacyAlgorithm :members: :undoc-members: + :no-index: -Protocol --------- - -.. autoclass:: Gmp +.. autoclass:: gvm.protocols.gmp.requests.v225.TicketStatus :members: - :inherited-members: + :undoc-members: + :no-index: diff --git a/docs/api/protocols.rst b/docs/api/protocols.rst index 7b75d235e..7e1458ce6 100644 --- a/docs/api/protocols.rst +++ b/docs/api/protocols.rst @@ -6,12 +6,9 @@ Protocols .. automodule:: gvm.protocols .. toctree:: - :maxdepth: 2 + :maxdepth: 1 - gmpv208 - gmpv214 - gmpv224 - gmpv225 + gmp ospv1 Dynamic diff --git a/docs/conf.py b/docs/conf.py index e0e2e37d8..4805d42cc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -139,6 +139,8 @@ autodoc_class_signature = "separated" +add_module_names = False + pygments_style = "zenburn" # -- Options for HTMLHelp output --------------------------------------------- diff --git a/docs/index.rst b/docs/index.rst index 923ce3082..9a606f428 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -4,7 +4,7 @@ Greenbone Vulnerability Management Python Library **python-gvm** is the official python library to control Greenbone Community Edition installations and Greenbone Enterprise Appliances remotely. -.. note:: **python-gvm** requires at least Python 3.7. Python 2 is not supported. +.. note:: **python-gvm** requires at least Python 3.9. Python 2 is not supported. User Guide ---------- diff --git a/gvm/_enum.py b/gvm/_enum.py index 2f883da1d..9cdcb99f9 100644 --- a/gvm/_enum.py +++ b/gvm/_enum.py @@ -4,7 +4,7 @@ # from enum import Enum as PythonEnum -from typing import Optional +from typing import Any, Optional from typing_extensions import Self @@ -16,6 +16,12 @@ class Enum(PythonEnum): Base class for Enums in python-gvm """ + @classmethod + def _missing_(cls, value: Any) -> Optional[Self]: + if isinstance(value, PythonEnum): + return cls.from_string(value.name) + return cls.from_string(str(value) if value else None) + @classmethod def from_string( cls, @@ -33,6 +39,9 @@ def from_string( return cls[value.replace(" ", "_").upper()] except KeyError: raise InvalidArgument( - f"Invalid argument {value} for {cls.__name__}.from_string. " + f"Invalid argument {value}. " f"Allowed values are {','.join(e.name for e in cls)}." ) from None + + def __str__(self) -> str: + return self.value diff --git a/gvm/connections.py b/gvm/connections.py deleted file mode 100644 index cf77cfccd..000000000 --- a/gvm/connections.py +++ /dev/null @@ -1,636 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# -""" -Module for connections to GVM server daemons like gvmd and ospd. -""" -import base64 -import errno -import hashlib -import logging -import socket as socketlib -import ssl -import sys -import time -from abc import ABC, abstractmethod -from os import PathLike -from pathlib import Path -from typing import Optional, Protocol, Union, runtime_checkable - -import paramiko -import paramiko.ssh_exception -import paramiko.transport -from lxml import etree - -from gvm.errors import GvmError - -logger = logging.getLogger(__name__) - -BUF_SIZE = 16 * 1024 -DEFAULT_READ_TIMEOUT = 60 # in seconds -DEFAULT_TIMEOUT = 60 # in seconds -DEFAULT_GVM_PORT = 9390 -DEFAULT_UNIX_SOCKET_PATH = "/run/gvmd/gvmd.sock" -DEFAULT_SSH_PORT = 22 -DEFAULT_SSH_USERNAME = "gmp" -DEFAULT_SSH_PASSWORD = "" -DEFAULT_HOSTNAME = "127.0.0.1" -DEFAULT_KNOWN_HOSTS_FILE = ".ssh/known_hosts" -MAX_SSH_DATA_LENGTH = 4095 - -Data = Union[str, bytes] - - -@runtime_checkable -class GvmConnection(Protocol): - def connect(self) -> None: ... - - def disconnect(self) -> None: ... - - def send(self, data: Data) -> None: ... - - def read(self) -> str: ... - - def finish_send(self): ... - - -class XmlReader: - """ - Read a XML command until its closing element - """ - - def start_xml(self) -> None: - self._first_element = None - # act on start and end element events and - # allow huge text data (for report content) - self._parser = etree.XMLPullParser( - events=("start", "end"), huge_tree=True - ) - - def is_end_xml(self) -> bool: - for action, obj in self._parser.read_events(): - if not self._first_element and action in "start": - self._first_element = obj.tag - - if ( - self._first_element - and action in "end" - and str(self._first_element) == str(obj.tag) - ): - return True - return False - - def feed_xml(self, data: Data) -> None: - try: - self._parser.feed(data) - except etree.ParseError as e: - raise GvmError( - f"Cannot parse XML response. Response data read {data}", - e, - ) from None - - -class AbstractGvmConnection(ABC): - """ - Base class for establishing a connection to a remote server daemon. - - Arguments: - timeout: Timeout in seconds for the connection. None to - wait indefinitely - """ - - def __init__(self, timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT): - self._socket = None - self._timeout = timeout if timeout is not None else DEFAULT_TIMEOUT - self._xml_reader = XmlReader() - - def _read(self) -> bytes: - if self._socket is None: - raise GvmError("Socket is not connected") - - return self._socket.recv(BUF_SIZE) - - @abstractmethod - def connect(self) -> None: - """Establish a connection to a remote server""" - raise NotImplementedError - - def send(self, data: Data) -> None: - """Send data to the connected remote server - - Arguments: - data: Data to be send to the server. Either utf-8 encoded string or - bytes. - """ - if self._socket is None: - raise GvmError("Socket is not connected") - - if isinstance(data, str): - self._socket.sendall(data.encode()) - else: - self._socket.sendall(data) - - def read(self) -> str: - """Read data from the remote server - - Returns: - str: data as utf-8 encoded string - """ - response = "" - - self._xml_reader.start_xml() - - break_timeout = ( - time.time() + self._timeout if self._timeout is not None else None - ) - - while True: - data = self._read() - - if not data: - # Connection was closed by server - raise GvmError("Remote closed the connection") - - self._xml_reader.feed_xml(data) - - response += data.decode("utf-8", errors="ignore") - - if self._xml_reader.is_end_xml(): - break - - if break_timeout and time.time() > break_timeout: - raise GvmError("Timeout while reading the response") - - return response - - def disconnect(self) -> None: - """Disconnect and close the connection to the remote server""" - try: - if self._socket is not None: - self._socket.close() - except OSError as e: - logger.debug("Connection closing error: %s", e) - - def finish_send(self): - """Indicate to the remote server you are done with sending data""" - if self._socket is not None: - # shutdown socket for sending. only allow reading data afterwards - self._socket.shutdown(socketlib.SHUT_WR) - - -class SSHConnection(AbstractGvmConnection): - """ - SSH Class to connect, read and write from GVM via SSH - - Arguments: - timeout: Timeout in seconds for the connection. - hostname: DNS name or IP address of the remote server. Default is - 127.0.0.1. - port: Port of the remote SSH server. Default is port 22. - username: Username to use for SSH login. Default is "gmp". - password: Password to use for SSH login. Default is "". - """ - - def __init__( - self, - *, - timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, - hostname: Optional[str] = DEFAULT_HOSTNAME, - port: Optional[int] = DEFAULT_SSH_PORT, - username: Optional[str] = DEFAULT_SSH_USERNAME, - password: Optional[str] = DEFAULT_SSH_PASSWORD, - known_hosts_file: Optional[Union[str, PathLike]] = None, - auto_accept_host: Optional[bool] = None, - ) -> None: - super().__init__(timeout) - self.hostname = hostname if hostname is not None else DEFAULT_HOSTNAME - self.port = int(port) if port is not None else DEFAULT_SSH_PORT - self.username = ( - username if username is not None else DEFAULT_SSH_USERNAME - ) - self.password = ( - password if password is not None else DEFAULT_SSH_PASSWORD - ) - self.known_hosts_file = ( - Path(known_hosts_file) - if known_hosts_file is not None - else Path.home() / DEFAULT_KNOWN_HOSTS_FILE - ) - self.auto_accept_host = auto_accept_host - - def _send_all(self, data: bytes) -> int: - """Returns the sum of sent bytes if success""" - sent_sum = 0 - while data: - sent = self._stdin.channel.send(data) - - if not sent: - # Connection was closed by server - raise GvmError("Remote closed the connection") - - sent_sum += sent - - data = data[sent:] - return sent_sum - - def _auto_accept_host( - self, hostkeys: paramiko.HostKeys, key: paramiko.PKey - ) -> None: - if self.port == DEFAULT_SSH_PORT: - hostkeys.add(self.hostname, key.get_name(), key) - elif self.port != DEFAULT_SSH_PORT: - hostkeys.add( - "[" + self.hostname + "]:" + str(self.port), - key.get_name(), - key, - ) - try: - hostkeys.save(filename=str(self.known_hosts_file)) - except OSError as e: - raise GvmError( - "Something went wrong with writing " - f"the known_hosts file: {e}" - ) from None - - key_type = key.get_name().replace("ssh-", "").upper() - - logger.info( - "Warning: Permanently added '%s' (%s) to " - "the list of known hosts.", - self.hostname, - key_type, - ) - - def _ssh_authentication_input_loop( - self, hostkeys: paramiko.HostKeys, key: paramiko.PKey - ) -> None: - # Ask user for permission to continue - # let it look like openssh - sha64_fingerprint = base64.b64encode( - hashlib.sha256(base64.b64decode(key.get_base64())).digest() - ).decode("utf-8")[:-1] - key_type = key.get_name().replace("ssh-", "").upper() - - print( - f"The authenticity of host '{self.hostname}' can't " - "be established." - ) - print(f"{key_type} key fingerprint is {sha64_fingerprint}.") - print("Are you sure you want to continue connecting (yes/no)? ", end="") - - add = input() - while True: - if add == "yes": - if self.port == DEFAULT_SSH_PORT: - hostkeys.add(self.hostname, key.get_name(), key) - elif self.port != DEFAULT_SSH_PORT: - hostkeys.add( - "[" + self.hostname + "]:" + str(self.port), - key.get_name(), - key, - ) - - # ask user if the key should be added permanently - print( - f"Do you want to add {self.hostname} " - "to known_hosts (yes/no)? ", - end="", - ) - - save = input() - while True: - if save == "yes": - try: - hostkeys.save(filename=str(self.known_hosts_file)) - except OSError as e: - raise GvmError( - "Something went wrong with writing " - f"the known_hosts file: {e}" - ) from None - - logger.info( - "Warning: Permanently added '%s' (%s) to " - "the list of known hosts.", - self.hostname, - key_type, - ) - break - elif save == "no": - logger.info( - "Warning: Host '%s' (%s) not added to " - "the list of known hosts.", - self.hostname, - key_type, - ) - break - else: - print("Please type 'yes' or 'no': ", end="") - save = input() - break - elif add == "no": - sys.exit("User denied key. Host key verification failed.") - else: - print("Please type 'yes' or 'no': ", end="") - add = input() - - def _get_remote_host_key(self) -> paramiko.PKey: - """Get the remote host key for ssh connection""" - try: - tmp_socket = socketlib.socket() - tmp_socket.settimeout(self._timeout) - tmp_socket.connect((self.hostname, self.port)) - except OSError as e: - raise GvmError( - "Couldn't establish a connection to fetch the" - f" remote server key: {e}" - ) from None - - trans = paramiko.transport.Transport(tmp_socket) - try: - trans.start_client() - except paramiko.SSHException as e: - raise GvmError( - f"Couldn't fetch the remote server key: {e}" - ) from None - key = trans.get_remote_server_key() - try: - trans.close() - except paramiko.SSHException as e: - raise GvmError( - f"Couldn't close the connection to the remote server key: {e}" - ) from None - return key - - def _ssh_authentication(self) -> None: - """Search/add/save the servers key for the SSH authentication process""" - - # set to reject policy (avoid MITM attacks) - self._socket.set_missing_host_key_policy(paramiko.RejectPolicy()) - # openssh is posix, so this might only a posix approach - # https://stackoverflow.com/q/32945533 - try: - # load the keys into paramiko and check if remote is in the list - self._socket.load_host_keys(filename=str(self.known_hosts_file)) - except OSError as e: - if e.errno != errno.ENOENT: - raise GvmError( - "Something went wrong with reading " - f"the known_hosts file: {e}" - ) from None - hostkeys = self._socket.get_host_keys() - # Switch based on SSH Port - if self.port == DEFAULT_SSH_PORT: - hostname = self.hostname - else: - hostname = f"[{self.hostname}]:{self.port}" - - if not hostkeys.lookup(hostname): - # Key not found, so connect to remote and fetch the key - # with the paramiko Transport protocol - key = self._get_remote_host_key() - if self.auto_accept_host: - self._auto_accept_host(hostkeys=hostkeys, key=key) - else: - self._ssh_authentication_input_loop(hostkeys=hostkeys, key=key) - - def connect(self) -> None: - """ - Connect to the SSH server and authenticate to it - """ - self._socket = paramiko.SSHClient() - self._ssh_authentication() - - try: - self._socket.connect( - hostname=self.hostname, - username=self.username, - password=self.password, - timeout=self._timeout, - port=int(self.port), - allow_agent=False, - look_for_keys=False, - ) - - self._stdin, self._stdout, self._stderr = self._socket.exec_command( - "", get_pty=False - ) - - except ( - paramiko.BadHostKeyException, - paramiko.AuthenticationException, - paramiko.SSHException, - paramiko.ssh_exception.NoValidConnectionsError, - ConnectionError, - ) as e: - raise GvmError(f"SSH Connection failed: {e}") from None - - def _read(self) -> bytes: - return self._stdout.channel.recv(BUF_SIZE) - - def send(self, data: Data) -> None: - if isinstance(data, str): - self._send_all(data.encode()) - else: - self._send_all(data) - - def finish_send(self) -> None: - # shutdown socket for sending. only allow reading data afterwards - self._stdout.channel.shutdown(socketlib.SHUT_WR) - - def disconnect(self) -> None: - """Disconnect and close the connection to the remote server""" - try: - if self._socket is not None: - self._socket.close() - except OSError as e: - logger.debug("Connection closing error: %s", e) - raise e - except AttributeError: - logger.debug("Connection might already be closed. No socket found.") - - if self._socket: - del self._socket, self._stdin, self._stdout, self._stderr - - -class TLSConnection(AbstractGvmConnection): - """ - TLS class to connect, read and write from a remote GVM daemon via TLS - secured socket. - - Arguments: - timeout: Timeout in seconds for the connection. - hostname: DNS name or IP address of the remote TLS server. - port: Port for the TLS connection. Default is 9390. - certfile: Path to PEM encoded certificate file. See - `python certificates`_ for details. - cafile: Path to PEM encoded CA file. See `python certificates`_ - for details. - keyfile: Path to PEM encoded private key. See `python certificates`_ - for details. - password: Password for the private key. If the password argument is not - specified and a password is required it will be interactively prompt - the user for a password. - - .. _python certificates: - https://docs.python.org/3/library/ssl.html#certificates - """ - - def __init__( - self, - *, - certfile: Optional[str] = None, - cafile: Optional[str] = None, - keyfile: Optional[str] = None, - hostname: Optional[str] = DEFAULT_HOSTNAME, - port: Optional[int] = DEFAULT_GVM_PORT, - password: Optional[str] = None, - timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, - ) -> None: - super().__init__(timeout=timeout) - - self.hostname = hostname if hostname is not None else DEFAULT_HOSTNAME - self.port = port if port is not None else DEFAULT_GVM_PORT - self.certfile = certfile - self.cafile = cafile - self.keyfile = keyfile - self.password = password - - def _new_socket(self): - transport_socket = socketlib.socket( - socketlib.AF_INET, socketlib.SOCK_STREAM - ) - - if self.certfile and self.cafile and self.keyfile: - context = ssl.create_default_context( - ssl.Purpose.SERVER_AUTH, cafile=self.cafile - ) - context.check_hostname = False - context.load_cert_chain( - certfile=self.certfile, - keyfile=self.keyfile, - password=self.password, - ) - context.minimum_version = ssl.TLSVersion.TLSv1_2 - else: - context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) - context.minimum_version = ssl.TLSVersion.TLSv1_2 - context.check_hostname = False - context.verify_mode = ssl.CERT_NONE - - sock = context.wrap_socket(transport_socket, server_side=False) - - sock.settimeout(self._timeout) - - return sock - - def connect(self) -> None: - self._socket = self._new_socket() - self._socket.connect((self.hostname, int(self.port))) - - def disconnect(self): - """Close the SSL layer then disconnect from the remote server""" - try: - if self._socket is not None: - self._socket = self._socket.unwrap() - except OSError as e: - logger.debug("Connection closing error: %s", e) - return super().disconnect() - - -class UnixSocketConnection(AbstractGvmConnection): - """ - UNIX-Socket class to connect, read, write from a daemon via direct - communicating UNIX-Socket - - Arguments: - path: Path to the socket. Default is "/run/gvmd/gvmd.sock". - timeout: Timeout in seconds for the connection. Default is 60 seconds. - """ - - def __init__( - self, - *, - path: Optional[str] = DEFAULT_UNIX_SOCKET_PATH, - timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, - ) -> None: - super().__init__(timeout=timeout) - - self.path = path if path is not None else DEFAULT_UNIX_SOCKET_PATH - - def connect(self) -> None: - """Connect to the UNIX socket""" - self._socket = socketlib.socket( - socketlib.AF_UNIX, socketlib.SOCK_STREAM - ) - self._socket.settimeout(self._timeout) - try: - self._socket.connect(self.path) - except FileNotFoundError: - raise GvmError(f"Socket {self.path} does not exist") from None - except ConnectionError as e: - raise GvmError( - f"Could not connect to socket {self.path}. Error was {e}" - ) from None - - -class DebugConnection: - """Wrapper around a connection for debugging purposes - - Allows to debug the connection flow including send and read data. Internally - it uses the python `logging`_ framework to create debug messages. Please - take a look at `the logging tutorial - `_ - for further details. - - Usage example: - - .. code-block:: python - - import logging - - logging.basicConfig(level=logging.DEBUG) - - socket_connection = UnixSocketConnection(path='/var/run/gvm.sock') - connection = DebugConnection(socket_connection) - gmp = Gmp(connection=connection) - - Arguments: - connection: GvmConnection to observe - - .. _logging: - https://docs.python.org/3/library/logging.html - """ - - def __init__(self, connection: GvmConnection): - self._connection = connection - - def read(self) -> str: - data = self._connection.read() - - logger.debug("Read %s characters. Data %s", len(data), data) - - self.last_read_data = data - return data - - def send(self, data: Data) -> None: - self.last_send_data = data - - logger.debug("Sending %s characters. Data %s", len(data), data) - - return self._connection.send(data) - - def connect(self) -> None: - logger.debug("Connecting") - - return self._connection.connect() - - def disconnect(self) -> None: - logger.debug("Disconnecting") - - return self._connection.disconnect() - - def finish_send(self) -> None: - logger.debug("Finish send") - - self._connection.finish_send() diff --git a/gvm/connections/__init__.py b/gvm/connections/__init__.py new file mode 100644 index 000000000..69cef9ce4 --- /dev/null +++ b/gvm/connections/__init__.py @@ -0,0 +1,32 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from ._connection import DEFAULT_TIMEOUT, GvmConnection +from ._debug import DebugConnection +from ._ssh import ( + DEFAULT_HOSTNAME, + DEFAULT_KNOWN_HOSTS_FILE, + DEFAULT_SSH_PASSWORD, + DEFAULT_SSH_PORT, + DEFAULT_SSH_USERNAME, + SSHConnection, +) +from ._tls import DEFAULT_GVM_PORT, TLSConnection +from ._unix import DEFAULT_UNIX_SOCKET_PATH, UnixSocketConnection + +__all__ = ( + "DEFAULT_TIMEOUT", + "DEFAULT_UNIX_SOCKET_PATH", + "DEFAULT_GVM_PORT", + "DEFAULT_HOSTNAME", + "DEFAULT_KNOWN_HOSTS_FILE", + "DEFAULT_SSH_PASSWORD", + "DEFAULT_SSH_USERNAME", + "DEFAULT_SSH_PORT", + "DebugConnection", + "GvmConnection", + "SSHConnection", + "TLSConnection", + "UnixSocketConnection", +) diff --git a/gvm/connections/_connection.py b/gvm/connections/_connection.py new file mode 100644 index 000000000..6a8bb8dc1 --- /dev/null +++ b/gvm/connections/_connection.py @@ -0,0 +1,124 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import logging +import socket as socketlib +from abc import ABC, abstractmethod +from time import time +from typing import Optional, Protocol, Union, runtime_checkable + +from gvm.errors import GvmError + +BUF_SIZE = 16 * 1024 + +DEFAULT_TIMEOUT = 60 # in seconds + +logger = logging.getLogger(__name__) + + +@runtime_checkable +class GvmConnection(Protocol): + """ + Python `protocol `_ + for GvmConnection classes. + """ + + def connect(self) -> None: + """Establish a connection to a remote server""" + + def disconnect(self) -> None: + """Send data to the connected remote server + + Arguments: + data: Data to be send to the server. Either utf-8 encoded string or + bytes. + """ + + def send(self, data: bytes) -> None: + """Send data to the connected remote server + + Args: + data: Data to be send to the server as bytes. + """ + + def read(self) -> bytes: + """Read data from the remote server + + Returns: + data as bytes + """ + + def finish_send(self): + """Indicate to the remote server you are done with sending data""" + + +class AbstractGvmConnection(ABC): + """ + Base class for establishing a connection to a remote server daemon. + + Arguments: + timeout: Timeout in seconds for the connection. None to + wait indefinitely + """ + + def __init__(self, timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT): + self._socket: Optional[socketlib.SocketType] = None + self._timeout = timeout if timeout is not None else DEFAULT_TIMEOUT + + def _read(self) -> bytes: + if self._socket is None: + raise GvmError("Socket is not connected") + + return self._socket.recv(BUF_SIZE) + + @abstractmethod + def connect(self) -> None: + """Establish a connection to a remote server""" + raise NotImplementedError + + def send(self, data: bytes) -> None: + """Send data to the connected remote server + + Args: + data: Data to be send to the server as bytes. + """ + if self._socket is None: + raise GvmError("Socket is not connected") + + self._socket.sendall(data) + + def read(self) -> bytes: + """Read data from the remote server + + Returns: + data as bytes + """ + break_timeout = ( + time() + self._timeout if self._timeout is not None else None + ) + + data = self._read() + + if not data: + # Connection was closed by server + raise GvmError("Remote closed the connection") + + if break_timeout and time() > break_timeout: + raise GvmError("Timeout while reading the response") + + return data + + def disconnect(self) -> None: + """Disconnect and close the connection to the remote server""" + try: + if self._socket is not None: + self._socket.close() + except OSError as e: + logger.debug("Connection closing error: %s", e) + + def finish_send(self): + """Indicate to the remote server you are done with sending data""" + if self._socket is not None: + # shutdown socket for sending. only allow reading data afterwards + self._socket.shutdown(socketlib.SHUT_WR) diff --git a/gvm/connections/_debug.py b/gvm/connections/_debug.py new file mode 100644 index 000000000..75df08794 --- /dev/null +++ b/gvm/connections/_debug.py @@ -0,0 +1,74 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import logging + +from ._connection import GvmConnection + +logger = logging.getLogger("gvm.connections.debug") + + +class DebugConnection: + """Wrapper around a connection for debugging purposes + + Allows to debug the connection flow including send and read data. Internally + it uses the python `logging`_ framework to create debug messages. Please + take a look at `the logging tutorial + `_ + for further details. + + Example: + + .. code-block:: python + + import logging + + logging.basicConfig(level=logging.DEBUG) + + socket_connection = UnixSocketConnection(path='/var/run/gvm.sock') + connection = DebugConnection(socket_connection) + gmp = Gmp(connection=connection) + + .. _logging: + https://docs.python.org/3/library/logging.html + """ + + def __init__(self, connection: GvmConnection): + """ + Create a new DebugConnection instance. + + Args: + connection: GvmConnection to observe + """ + self._connection = connection + + def read(self) -> bytes: + data = self._connection.read() + + logger.debug("Read %s characters. Data %r", len(data), data) + + self.last_read_data = data + return data + + def send(self, data: bytes) -> None: + self.last_send_data = data + + logger.debug("Sending %s characters. Data %r", len(data), data) + + return self._connection.send(data) + + def connect(self) -> None: + logger.debug("Connecting") + + return self._connection.connect() + + def disconnect(self) -> None: + logger.debug("Disconnecting") + + return self._connection.disconnect() + + def finish_send(self) -> None: + logger.debug("Finish send") + + self._connection.finish_send() diff --git a/gvm/connections/_ssh.py b/gvm/connections/_ssh.py new file mode 100644 index 000000000..f82ef80eb --- /dev/null +++ b/gvm/connections/_ssh.py @@ -0,0 +1,352 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import base64 +import errno +import hashlib +import logging +import socket as socketlib +import sys +from os import PathLike +from pathlib import Path +from time import time +from typing import Any, Callable, Optional, TextIO, Union + +import paramiko +import paramiko.ssh_exception +import paramiko.transport + +from gvm.errors import GvmError + +from ._connection import BUF_SIZE, DEFAULT_TIMEOUT + +logger = logging.getLogger("gvm.connections.ssh") + +DEFAULT_SSH_PORT = 22 +DEFAULT_SSH_USERNAME = "gmp" +DEFAULT_SSH_PASSWORD = "" +DEFAULT_HOSTNAME = "127.0.0.1" +DEFAULT_KNOWN_HOSTS_FILE = ".ssh/known_hosts" + + +class SSHConnection: + """ + SSH Class to connect, read and write from GVM via SSH + + """ + + def __init__( + self, + *, + timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, + hostname: Optional[str] = DEFAULT_HOSTNAME, + port: Optional[int] = DEFAULT_SSH_PORT, + username: Optional[str] = DEFAULT_SSH_USERNAME, + password: Optional[str] = DEFAULT_SSH_PASSWORD, + known_hosts_file: Optional[Union[str, PathLike]] = None, + auto_accept_host: Optional[bool] = None, + file: TextIO = sys.stdout, + input: Callable[[], str] = input, + exit: Callable[[str], Any] = sys.exit, + ) -> None: + """ + Create a new SSH connection instance. + + Args: + timeout: Timeout in seconds for the connection. + hostname: DNS name or IP address of the remote server. Default is + 127.0.0.1. + port: Port of the remote SSH server. Default is port 22. + username: Username to use for SSH login. Default is "gmp". + password: Password to use for SSH login. Default is "". + """ + self._client: Optional[paramiko.SSHClient] = None + self.hostname = hostname if hostname is not None else DEFAULT_HOSTNAME + self.port = int(port) if port is not None else DEFAULT_SSH_PORT + self.username = ( + username if username is not None else DEFAULT_SSH_USERNAME + ) + self.password = ( + password if password is not None else DEFAULT_SSH_PASSWORD + ) + self.known_hosts_file = ( + Path(known_hosts_file) + if known_hosts_file is not None + else Path.home() / DEFAULT_KNOWN_HOSTS_FILE + ) + self.auto_accept_host = auto_accept_host + self._timeout = timeout + self._file = file + self._input = input + self._exit = exit + + def _send_all(self, data: bytes) -> int: + """Returns the sum of sent bytes if success""" + sent_sum = 0 + while data: + sent = self._stdin.channel.send(data) + + if not sent: + # Connection was closed by server + raise GvmError("Remote closed the connection") + + sent_sum += sent + + data = data[sent:] + return sent_sum + + def _auto_accept_host( + self, hostkeys: paramiko.HostKeys, key: paramiko.PKey + ) -> None: + if self.port == DEFAULT_SSH_PORT: + hostkeys.add(self.hostname, key.get_name(), key) + elif self.port != DEFAULT_SSH_PORT: + hostkeys.add( + "[" + self.hostname + "]:" + str(self.port), + key.get_name(), + key, + ) + try: + hostkeys.save(filename=str(self.known_hosts_file)) + except OSError as e: + raise GvmError( + "Something went wrong with writing " + f"the known_hosts file {self.known_hosts_file.absolute()}: {e}" + ) from None + + key_type = key.get_name().replace("ssh-", "").upper() + + logger.info( + "Warning: Permanently added '%s' (%s) to " + "the list of known hosts.", + self.hostname, + key_type, + ) + + def _ssh_authentication_input_loop( + self, hostkeys: paramiko.HostKeys, key: paramiko.PKey + ) -> None: + # Ask user for permission to continue + # let it look like openssh + sha64_fingerprint = base64.b64encode( + hashlib.sha256(base64.b64decode(key.get_base64())).digest() + ).decode("utf-8")[:-1] + key_type = key.get_name().replace("ssh-", "").upper() + + print( + f"The authenticity of host '{self.hostname}' can't " + "be established.", + file=self._file, + ) + print( + f"{key_type} key fingerprint is {sha64_fingerprint}.", + file=self._file, + ) + print( + "Are you sure you want to continue connecting (yes/no)? ", + end="", + file=self._file, + ) + + add = self._input() + while True: + if add == "yes": + if self.port == DEFAULT_SSH_PORT: + hostkeys.add(self.hostname, key.get_name(), key) + elif self.port != DEFAULT_SSH_PORT: + hostkeys.add( + "[" + self.hostname + "]:" + str(self.port), + key.get_name(), + key, + ) + + # ask user if the key should be added permanently + print( + f"Do you want to add {self.hostname} " + "to known_hosts (yes/no)? ", + end="", + file=self._file, + ) + + save = self._input() + while True: + if save == "yes": + try: + hostkeys.save(filename=str(self.known_hosts_file)) + except OSError as e: + raise GvmError( + "Something went wrong with writing " + f"the known_hosts file: {e}" + ) from None + + logger.info( + "Warning: Permanently added '%s' (%s) to " + "the list of known hosts.", + self.hostname, + key_type, + ) + break + elif save == "no": + logger.info( + "Warning: Host '%s' (%s) not added to " + "the list of known hosts.", + self.hostname, + key_type, + ) + break + else: + print( + "Please type 'yes' or 'no': ", + end="", + file=self._file, + ) + save = self._input() + break + elif add == "no": + self._exit("User denied key. Host key verification failed.") + else: + print("Please type 'yes' or 'no': ", end="", file=self._file) + add = self._input() + + def _get_remote_host_key(self) -> paramiko.PKey: + """Get the remote host key for ssh connection""" + try: + tmp_socket = socketlib.socket() + tmp_socket.settimeout(self._timeout) + tmp_socket.connect((self.hostname, self.port)) + except OSError as e: + tmp_socket.close() + raise GvmError( + "Couldn't establish a connection to fetch the" + f" remote server key: {e}" + ) from None + + trans = paramiko.transport.Transport(tmp_socket) + try: + trans.start_client() + except paramiko.SSHException as e: + tmp_socket.close() + raise GvmError( + f"Couldn't fetch the remote server key: {e}" + ) from None + + key = trans.get_remote_server_key() + try: + trans.close() + except paramiko.SSHException as e: + raise GvmError( + f"Couldn't close the connection to the remote server key: {e}" + ) from None + finally: + tmp_socket.close() + + return key + + def _ssh_authentication(self) -> None: + """Search/add/save the servers key for the SSH authentication process""" + + if not self._client: + raise GvmError("SSH Client not connected.") + + # set to reject policy (avoid MITM attacks) + self._client.set_missing_host_key_policy(paramiko.RejectPolicy()) + + # openssh is posix, so this might only a posix approach + # https://stackoverflow.com/q/32945533 + try: + # load the keys into paramiko and check if remote is in the list + self._client.load_host_keys(filename=str(self.known_hosts_file)) + except OSError as e: + if e.errno != errno.ENOENT: + raise GvmError( + "Something went wrong with reading " + f"the known_hosts file: {e}" + ) from None + + hostkeys = self._client.get_host_keys() + + # Switch based on SSH Port + if self.port == DEFAULT_SSH_PORT: + hostname = self.hostname + else: + hostname = f"[{self.hostname}]:{self.port}" + + if not hostkeys.lookup(hostname): + # Key not found, so connect to remote and fetch the key + # with the paramiko Transport protocol + key = self._get_remote_host_key() + if self.auto_accept_host: + self._auto_accept_host(hostkeys=hostkeys, key=key) + else: + self._ssh_authentication_input_loop(hostkeys=hostkeys, key=key) + + def _read(self) -> bytes: + return self._stdout.channel.recv(BUF_SIZE) + + def send(self, data: bytes) -> None: + self._send_all(data) + + def read(self) -> bytes: + break_timeout = ( + time() + self._timeout if self._timeout is not None else None + ) + + data = self._read() + + if not data: + # Connection was closed by server + raise GvmError("Remote closed the connection") + + if break_timeout and time() > break_timeout: + raise GvmError("Timeout while reading the response") + + return data + + def connect(self) -> None: + """ + Connect to the SSH server and authenticate to it + """ + self._client = paramiko.SSHClient() + self._ssh_authentication() + + try: + self._client.connect( + hostname=self.hostname, + username=self.username, + password=self.password, + timeout=self._timeout, + port=int(self.port), + allow_agent=False, + look_for_keys=False, + ) + + except ( + paramiko.BadHostKeyException, + paramiko.AuthenticationException, + paramiko.SSHException, + paramiko.ssh_exception.NoValidConnectionsError, + ConnectionError, + ) as e: + raise GvmError(f"SSH Connection failed: {e}") from None + + self._stdin, self._stdout, self._stderr = self._client.exec_command( + "", get_pty=False + ) + + def disconnect(self) -> None: + """Disconnect and close the connection to the remote server""" + try: + if self._client is not None: + self._client.close() + except OSError as e: + logger.debug("Connection closing error: %s", e) + raise e + + if self._client is not None: + self._client = None + del self._stdin, self._stdout, self._stderr + + def finish_send(self) -> None: + # shutdown socket for sending. only allow reading data afterwards + self._stdout.channel.shutdown(socketlib.SHUT_WR) diff --git a/gvm/connections/_tls.py b/gvm/connections/_tls.py new file mode 100644 index 000000000..de519ad70 --- /dev/null +++ b/gvm/connections/_tls.py @@ -0,0 +1,104 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import logging +import socket as socketlib +import ssl +from typing import Optional, Union + +from ._connection import DEFAULT_TIMEOUT, AbstractGvmConnection + +DEFAULT_GVM_PORT = 9390 +DEFAULT_HOSTNAME = "127.0.0.1" +DEFAULT_KNOWN_HOSTS_FILE = ".ssh/known_hosts" + +logger = logging.getLogger("gvm.connections.tls") + + +class TLSConnection(AbstractGvmConnection): + """ + TLS class to connect, read and write from a remote GVM daemon via TLS + secured socket. + """ + + def __init__( + self, + *, + certfile: Optional[str] = None, + cafile: Optional[str] = None, + keyfile: Optional[str] = None, + hostname: Optional[str] = DEFAULT_HOSTNAME, + port: Optional[int] = DEFAULT_GVM_PORT, + password: Optional[str] = None, + timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, + ) -> None: + """ + Create a new TLSConnection instance. + + Args: + timeout: Timeout in seconds for the connection. + hostname: DNS name or IP address of the remote TLS server. + port: Port for the TLS connection. Default is 9390. + certfile: Path to PEM encoded certificate file. See + `python certificates`_ for details. + cafile: Path to PEM encoded CA file. See `python certificates`_ + for details. + keyfile: Path to PEM encoded private key. See `python certificates`_ + for details. + password: Password for the private key. If the password argument is not + specified and a password is required it will be interactively prompt + the user for a password. + + .. _python certificates: + https://docs.python.org/3/library/ssl.html#certificates + """ + super().__init__(timeout=timeout) + + self.hostname = hostname if hostname is not None else DEFAULT_HOSTNAME + self.port = port if port is not None else DEFAULT_GVM_PORT + self.certfile = certfile + self.cafile = cafile + self.keyfile = keyfile + self.password = password + + def _new_socket(self) -> ssl.SSLSocket: + transport_socket = socketlib.socket( + socketlib.AF_INET, socketlib.SOCK_STREAM + ) + + if self.certfile and self.cafile and self.keyfile: + context = ssl.create_default_context( + ssl.Purpose.SERVER_AUTH, cafile=self.cafile + ) + context.check_hostname = False + context.load_cert_chain( + certfile=self.certfile, + keyfile=self.keyfile, + password=self.password, + ) + context.minimum_version = ssl.TLSVersion.TLSv1_2 + else: + context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) + context.minimum_version = ssl.TLSVersion.TLSv1_2 + context.check_hostname = False + context.verify_mode = ssl.CERT_NONE + + sock = context.wrap_socket(transport_socket, server_side=False) + + sock.settimeout(self._timeout) + + return sock + + def connect(self) -> None: + self._socket = self._new_socket() + self._socket.connect((self.hostname, int(self.port))) + + def disconnect(self): + """Close the SSL layer then disconnect from the remote server""" + try: + if self._socket is not None: + self._socket = self._socket.unwrap() + except OSError as e: + logger.debug("Connection closing error: %s", e) + return super().disconnect() diff --git a/gvm/connections/_unix.py b/gvm/connections/_unix.py new file mode 100644 index 000000000..8224d8619 --- /dev/null +++ b/gvm/connections/_unix.py @@ -0,0 +1,54 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import socket as socketlib +from os import PathLike, fspath +from typing import Optional, Union + +from gvm.errors import GvmError + +from ._connection import DEFAULT_TIMEOUT, AbstractGvmConnection + +DEFAULT_UNIX_SOCKET_PATH = "/run/gvmd/gvmd.sock" + + +class UnixSocketConnection(AbstractGvmConnection): + """ + UNIX-Socket class to connect, read, write from a daemon via direct + communicating UNIX-Socket + """ + + def __init__( + self, + *, + path: Optional[Union[str, PathLike[str]]] = DEFAULT_UNIX_SOCKET_PATH, + timeout: Optional[Union[int, float]] = DEFAULT_TIMEOUT, + ) -> None: + """ + Create a new UnixSocketConnection instance. + + Args: + path: Path to the socket. Default is "/run/gvmd/gvmd.sock". + timeout: Timeout in seconds for the connection. Default is 60 seconds. + """ + super().__init__(timeout=timeout) + + self.path = ( + fspath(path) if path is not None else DEFAULT_UNIX_SOCKET_PATH + ) + + def connect(self) -> None: + """Connect to the UNIX socket""" + self._socket = socketlib.socket( + socketlib.AF_UNIX, socketlib.SOCK_STREAM + ) + self._socket.settimeout(self._timeout) + try: + self._socket.connect(self.path) + except FileNotFoundError: + raise GvmError(f"Socket {self.path} does not exist") from None + except ConnectionError as e: + raise GvmError( + f"Could not connect to socket {self.path}. Error was {e}" + ) from None diff --git a/gvm/errors.py b/gvm/errors.py index 2b809ba51..cdb715832 100644 --- a/gvm/errors.py +++ b/gvm/errors.py @@ -15,7 +15,7 @@ class GvmError(Exception): Base class for all exceptions originating in python-gvm. """ - def __init__(self, message: str, *args): + def __init__(self, message: Optional[str], *args): super().__init__(message, *args) self.message = message @@ -44,7 +44,9 @@ class GvmServerError(GvmError): and function """ - def __init__(self, status: str = None, message: str = None): + def __init__( + self, status: Optional[str] = None, message: Optional[str] = None + ): super().__init__(message, status) self.status = status @@ -69,7 +71,9 @@ class GvmResponseError(GvmClientError): and function """ - def __init__(self, status: str = None, message: str = None): + def __init__( + self, status: Optional[str] = None, message: Optional[str] = None + ): super().__init__(message, status) self.status = status @@ -132,9 +136,9 @@ class InvalidArgumentType(GvmError): def __init__( self, - argument: str = None, - arg_type: str = None, + argument: str, *, + arg_type: Optional[str] = None, function: Optional[str] = None, ): super().__init__(None) @@ -144,11 +148,21 @@ def __init__( def __str__(self): if self.function: + if self.arg_type: + return ( + f"In {self.function} the argument {self.argument} " + f"must be of type {self.arg_type}." + ) return ( - f"In {self.function} the argument {self.argument} " - f"must be of type {self.arg_type}." + f"Invalid argument type for argument {self.argument} in " + f"{self.function}." ) - return f"The argument {self.argument} must be of type {self.arg_type}." + if self.arg_type: + return ( + f"The argument {self.argument} must be of type {self.arg_type}." + ) + + return f"Invalid argument type for argument {self.argument}." class RequiredArgument(GvmError): diff --git a/gvm/protocols/__init__.py b/gvm/protocols/__init__.py index f6f46a71b..3be775ebf 100644 --- a/gvm/protocols/__init__.py +++ b/gvm/protocols/__init__.py @@ -5,18 +5,13 @@ """ Package for supported Greenbone Protocol versions. -Currently `GMP version 20.08`_, `GMP version 21.04`_ -`GMP version 22.04`_, `GMP version 22.05`_ +Currently `GMP version 22.04`_, `GMP version 22.05`_ and `OSP version 1`_ are supported. -.. _GMP version 20.08: - https://docs.greenbone.net/API/GMP/gmp-20.08.html -.. _GMP version 21.04: - https://docs.greenbone.net/API/GMP/gmp-21.04.html .. _GMP version 22.04: https://docs.greenbone.net/API/GMP/gmp-22.04.html .. _GMP version 22.05: - https://docs.greenbone.net/API/GMP/gmp-22.05.html + https://docs.greenbone.net/API/GMP/gmp-22.05.html .. _OSP version 1: https://docs.greenbone.net/API/OSP/osp-1.2.html """ diff --git a/gvm/protocols/_protocol.py b/gvm/protocols/_protocol.py new file mode 100644 index 000000000..b51e567bb --- /dev/null +++ b/gvm/protocols/_protocol.py @@ -0,0 +1,137 @@ +# SPDX-FileCopyrightText: 2019-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from types import TracebackType +from typing import Callable, Generic, Optional, Type + +from typing_extensions import Self, TypeVar + +from gvm.connections import GvmConnection + +from .core import Connection, Request, Response + +T = TypeVar("T", default=str) + + +def str_transform(response: Response) -> str: + return str(response) + + +class GvmProtocol(Generic[T]): + """Base class for different GVM protocols""" + + def __init__( + self, + connection: GvmConnection, + *, + transform: Callable[[Response], T] = str_transform, # type: ignore[assignment] + ): + """ + Create a new GvmProtocol instance. + + Args: + connection: Connection to use to talk with the remote daemon. See + :mod:`gvm.connections` for possible connection types. + transform: Optional transform callable to convert response data. + After each request the callable gets passed the plain response data + which can be used to check the data and/or conversion into different + representations like a xml dom. + """ + self._connection = connection + self._protocol = Connection() + + self._connected = False + + self._transform_callable = transform + + def __enter__(self) -> Self: + self.connect() + return self + + def __exit__( + self, + exc_type: Optional[Type[BaseException]], + exc_value: Optional[BaseException], + traceback: Optional[TracebackType], + ) -> None: + self.disconnect() + + def _read(self) -> bytes: + """Read a command response from gvmd + + Returns: + str: Response from server. + """ + return self._connection.read() + + def _send(self, data: bytes) -> None: + """Send a command to the server + + Arguments: + data (str): Data to be send over the connection to the server + """ + self.connect() + self._connection.send(data) + + def is_connected(self) -> bool: + """Status of the current connection + + Returns: + True if a connection to the remote server has been established. + """ + return self._connected + + def connect(self) -> None: + """Initiates a protocol connection + + Normally connect is not called directly. Either it is called + automatically when sending a protocol command or when using a + `with statement`_. + + .. _with statement: + https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers + """ + if not self.is_connected(): + self._connection.connect() + self._connected = True + + def disconnect(self) -> None: + """Disconnect the connection + + Ends and closes the connection. + """ + if self.is_connected(): + self._connection.disconnect() + self._connected = False + + self._protocol.close() + + def send_command(self, cmd: str) -> str: + """ + Send a string command to the remote daemon and return the response as + string + """ + return bytes( + self._send_command(cmd.encode("utf-8", errors="ignore")) # type: ignore[arg-type] # it seems mypy on Python < 3.11 can't handle bytes here + ).decode("utf-8", errors="ignore") + + def _transform(self, response: Response) -> T: + transform = self._transform_callable + return transform(response) + + def _send_command(self, cmd: Request) -> Response: + try: + send_data = self._protocol.send(cmd) + self._send(send_data) + response: Optional[Response] = None + while not response: + received_data = self._read() + response = self._protocol.receive_data(received_data) + return response + except Exception as e: + self.disconnect() + raise e + + def _send_and_transform_command(self, cmd: Request) -> T: + return self._transform(self._send_command(cmd)) diff --git a/gvm/protocols/base.py b/gvm/protocols/base.py deleted file mode 100644 index e118ef888..000000000 --- a/gvm/protocols/base.py +++ /dev/null @@ -1,129 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, Callable, Optional - -from gvm.connections import GvmConnection - - -class GvmProtocol: - """Base class for different GVM protocols - - Attributes: - connection: Connection to use to talk with the remote daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - self._connection = connection - - self._connected = False - - self._transform_callable = transform - - def __enter__(self): - self.connect() - return self - - def __exit__(self, exc_type, exc_value, traceback): - self.disconnect() - - def _read(self): - """Read a command response from gvmd - - Returns: - str: Response from server. - """ - return self._connection.read() - - def _send(self, data): - """Send a command to the server - - Arguments: - data (str): Data to be send over the connection to the server - """ - self.connect() - self._connection.send(data) - - def _transform(self, data): - transform = self._transform_callable - if transform is None: - return data - return transform(data) - - def _send_xml_command(self, xmlcmd): - """Send a xml command to the remote server - - Arguments: - xmlcmd (gvm.xml.XmlCommand): XmlCommand instance to send - """ - return self.send_command(xmlcmd.to_string()) - - def is_connected(self) -> bool: - """Status of the current connection - - Returns: - True if a connection to the remote server has been established. - """ - return self._connected - - def connect(self): - """Initiates a protocol connection - - Normally connect is not called directly. Either it is called - automatically when sending a protocol command or when using a - `with statement`_. - - .. _with statement: - https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers - """ - if not self.is_connected(): - self._connection.connect() - self._connected = True - - def disconnect(self): - """Disconnect the connection - - Ends and closes the connection. - """ - if self.is_connected(): - self._connection.disconnect() - self._connected = False - - def send_command(self, cmd: str) -> Any: - """Send a command to the remote server - - If the class is not connected to the server yet the connection will be - established automatically. - - Arguments: - cmd (str): Command as string to be send over the connection to - the server. - - Returns: - any: The actual returned type depends on the set transform. - - Per default - if no transform is set explicitly - the response is - returned as string. - """ - try: - self._send(cmd) - response = self._read() - except Exception as e: - self.disconnect() - raise e - - return self._transform(response) diff --git a/gvm/protocols/core/__init__.py b/gvm/protocols/core/__init__.py new file mode 100644 index 000000000..726650f70 --- /dev/null +++ b/gvm/protocols/core/__init__.py @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from ._connection import Connection, InvalidStateError +from ._request import Request +from ._response import Response, StatusError + +__all__ = ( + "Connection", + "InvalidStateError", + "Request", + "Response", + "StatusError", +) diff --git a/gvm/protocols/core/_connection.py b/gvm/protocols/core/_connection.py new file mode 100644 index 000000000..4c56cf87d --- /dev/null +++ b/gvm/protocols/core/_connection.py @@ -0,0 +1,201 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import AnyStr, Optional, Protocol + +from lxml import etree + +from gvm.errors import GvmError + +from ._request import Request +from ._response import Response + + +class XmlReader: + """ + Read a XML command until its closing element + """ + + def start_xml(self) -> None: + self._first_element: Optional[etree._Element] = None + # act on start and end element events and + # allow huge text data (for report content) + self._parser = etree.XMLPullParser( + events=("start", "end"), huge_tree=True + ) + + def is_end_xml(self) -> bool: + for action, obj in self._parser.read_events(): + if not self._first_element and action in "start": + self._first_element = obj.tag # type: ignore + + if ( + self._first_element + and action in "end" + and str(self._first_element) == str(obj.tag) # type: ignore + ): + return True + return False + + def feed_xml(self, data: AnyStr) -> None: + try: + self._parser.feed(data) + except etree.ParseError as e: + raise GvmError( + f"Cannot parse XML response. Response data read {data!r}", + e, + ) from None + + +class InvalidStateError(GvmError): + """ + Error raised if the Connection would be moved into an invalid state + """ + + def __init__(self, message: str = "Invalid State", *args): + super().__init__(message, *args) + + +class State(Protocol): + def __set_context__(self, context: "Context") -> None: ... + def send(self, request: Request) -> bytes: ... + def receive_data(self, data: bytes) -> Optional[Response]: ... + def close(self) -> None: ... + + +class Context(Protocol): + def __set_state__(self, state: State) -> None: ... + + +class AbstractState: + _context: Context + + def __set_context__(self, context: Context) -> None: + self._context = context + + def set_next_state(self, next_state: State) -> None: + self._context.__set_state__(next_state) + + +class InitialState(AbstractState): + def send(self, request: Request) -> bytes: + self.set_next_state(AwaitingResponseState(request)) + return bytes(request) + + def receive_data(self, data: bytes) -> Optional[Response]: + raise InvalidStateError() + + def close(self) -> None: + # nothing to do + return + + +class AwaitingResponseState(AbstractState): + def __init__(self, request: Request) -> None: + self._request = request + + def send(self, request: Request) -> bytes: + raise InvalidStateError() + + def close(self) -> None: + self.set_next_state(InitialState()) + + def receive_data(self, data: bytes) -> Optional[Response]: + next_state = ReceivingDataState(self._request) + self.set_next_state(next_state) + return next_state.receive_data(data) + + +class ErrorState(AbstractState): + message = ( + "The connection is in an error state. Please close the connection." + ) + + def send(self, request: Request) -> bytes: + raise InvalidStateError(self.message) + + def close(self) -> None: + self.set_next_state(InitialState()) + + def receive_data(self, data: bytes) -> Optional[Response]: + raise InvalidStateError(self.message) + + +class ReceivingDataState(AbstractState): + def __init__(self, request: Request) -> None: + self._request = request + self._data = bytearray() + self._reader = XmlReader() + self._reader.start_xml() + + def send(self, request: Request) -> bytes: + raise InvalidStateError() + + def close(self) -> None: + self.set_next_state(InitialState()) + + def receive_data(self, data: bytes) -> Optional[Response]: + self._data += data + try: + self._reader.feed_xml(data) + except GvmError as e: + self.set_next_state(ErrorState()) + raise e + + if not self._reader.is_end_xml(): + return None + + self.set_next_state(InitialState()) + return Response(data=bytes(self._data), request=self._request) + + +class Connection: + """ + This is a [SansIO](https://sans-io.readthedocs.io) connection for GMP + + It is responsible for creating bytes from GMP XML requests and transforming + XML response data into GMP responses. + """ + + def __init__(self) -> None: + self.__set_state__(InitialState()) + + def send(self, request: Request) -> bytes: + """ + Create data from a request to be send + + Returns: + The data for a request that can be send for example over a socket + + Raises: + An InvalidStateError if no request can be send currently. For + example when waiting for a response to a previous request. + """ + return self._state.send(request) + + def receive_data(self, data: bytes) -> Optional[Response]: + """ + Feed received data a response is complete + + Returns: + A Response if the response data is complete and None if data is + still to be received. + + Raises: + An InvalidStateError if no data can be received currently. For + example if not request is send yet. + """ + return self._state.receive_data(data) + + def close(self) -> None: + """ + Close the connection and reset the state of the protocol + + Afterwards the connection can be reused for sending a new request. + """ + return self._state.close() + + def __set_state__(self, state: State) -> None: + self._state = state + self._state.__set_context__(self) diff --git a/gvm/protocols/core/_request.py b/gvm/protocols/core/_request.py new file mode 100644 index 000000000..f26bda00b --- /dev/null +++ b/gvm/protocols/core/_request.py @@ -0,0 +1,16 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Protocol, runtime_checkable + + +@runtime_checkable +class Request(Protocol): + """ + A GMP Request Python Protocol + + A Request implementation may be provided by several classes + """ + + def __bytes__(self) -> bytes: ... diff --git a/gvm/protocols/core/_response.py b/gvm/protocols/core/_response.py new file mode 100644 index 000000000..83fca5a24 --- /dev/null +++ b/gvm/protocols/core/_response.py @@ -0,0 +1,114 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from functools import cached_property +from typing import Optional + +from typing_extensions import Self + +from gvm.errors import GvmError +from gvm.xml import Element, parse_xml + +from ._request import Request + + +class StatusError(GvmError): + """ + The response had an error status + + May be raised when calling `response.raise_for_status()` + """ + + def __init__(self, message: Optional[str], *args, response: "Response"): + super().__init__(message, *args) + self.response = response + self.request = response.request + + +class Response: + """ + A GMP Response + """ + + def __init__(self, *, request: Request, data: bytes) -> None: + """ + Create a Response object + + Args: + request: The request corresponding to this response + data: The data of the response + """ + self._request = request + self._data = data + self.__xml: Optional[Element] = None + + def __root_element(self) -> Element: + if self.__xml is None: + self.__xml = self.xml() + return self.__xml + + def xml(self) -> Element: + """ + Return the response data as XML Element + + Raises XmlError if the data is not valid XML. + """ + return parse_xml(self.data) + + @property + def data(self) -> bytes: + """ + Return the data of the response as bytes + """ + return self._data + + @property + def request(self) -> Request: + """ + Return the corresponding request of this response + """ + return self._request + + @cached_property + def status_code(self) -> Optional[int]: + """ + The status code of the response + + Returns: + The status code or None if the response data doesn't contain a valid + status code. + """ + root = self.__root_element() + try: + status = root.attrib["status"] + return int(status) + except (KeyError, ValueError): + return None + + @property + def is_success(self) -> bool: + """ + Returns True if the response contains a success status code + """ + status = self.status_code + return status is not None and 200 <= status <= 299 + + def raise_for_status(self) -> Self: + if self.is_success: + return self + raise StatusError( + f"Invalid status code {self.status_code}", response=self + ) + + def __bytes__(self) -> bytes: + """ + Return the data as bytes + """ + return self._data + + def __str__(self) -> str: + """ + Return the data as string + """ + return self._data.decode() diff --git a/gvm/protocols/gmp.py b/gvm/protocols/gmp.py deleted file mode 100644 index d5b04483d..000000000 --- a/gvm/protocols/gmp.py +++ /dev/null @@ -1,119 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -""" -Module for communication with gvmd -""" -from types import TracebackType -from typing import Any, Callable, Optional, Type, Union - -from gvm.errors import GvmError -from gvm.protocols.base import GvmConnection, GvmProtocol -from gvm.protocols.gmpv208 import Gmp as Gmpv208 -from gvm.protocols.gmpv214 import Gmp as Gmpv214 -from gvm.protocols.gmpv224 import Gmp as Gmpv224 -from gvm.protocols.gmpv225 import Gmp as Gmpv225 -from gvm.transforms import EtreeCheckCommandTransform -from gvm.xml import XmlCommand - -SUPPORTED_GMP_VERSIONS = Union[ # pylint: disable=invalid-name - Gmpv208, Gmpv214, Gmpv224, Gmpv225 -] - - -class Gmp(GvmProtocol): - """Dynamically select supported GMP protocol of the remote manager daemon. - - Must be used as a `Context Manager - `_ - - Example: - - .. code-block:: python - - from gvm.protocols.gmp import Gmp - - with Gmp(connection) as gmp: - # gmp can be an instance of gvm.protocols.gmpv208.Gmp, - # gvm.protocols.gmpv214.Gmp depending - # on the supported GMP version of the remote manager daemon - resp = gmp.get_tasks() - - Attributes: - connection: Connection to use to talk with the remote daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - - .. _callable: - https://docs.python.org/3/library/functions.html#callable - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - super().__init__(connection, transform=EtreeCheckCommandTransform()) - self._gmp_transform = transform - - def determine_remote_gmp_version(self) -> str: - """Determine the supported GMP version of the remote daemon""" - self.connect() - resp = self._send_xml_command(XmlCommand("get_version")) - self.disconnect() - - version_el = resp.find("version") - if version_el is None: - raise GvmError( - "Invalid response from manager daemon while requesting the " - "version information." - ) - - return version_el.text - - def determine_supported_gmp(self) -> SUPPORTED_GMP_VERSIONS: - """Determine supported GMP version of the remote daemon and return a - corresponding Gmp class instance - """ - version_str = self.determine_remote_gmp_version().split(".", 1) - major_version = int(version_str[0]) - minor_version = int(version_str[1]) - if major_version == 20: - gmp_class = Gmpv208 - elif major_version == 21 and minor_version == 4: - gmp_class = Gmpv214 - elif major_version == 22 and minor_version == 4: - gmp_class = Gmpv224 - elif major_version == 22 and minor_version == 5: - gmp_class = Gmpv225 - else: - raise GvmError( - "Remote manager daemon uses an unsupported version of GMP. " - f"The GMP version was {major_version}.{minor_version}" - ) - - return gmp_class(self._connection, transform=self._gmp_transform) - - def __enter__(self): - self._gmp = self.determine_supported_gmp() - - self._gmp.connect() - - return self._gmp - - def __exit__( - self, - exc_type: Optional[Type[BaseException]], - exc_value: Optional[BaseException], - traceback: Optional[TracebackType], - ) -> Any: - self._gmp.disconnect() - self._gmp = None diff --git a/gvm/protocols/gmp/__init__.py b/gvm/protocols/gmp/__init__.py new file mode 100644 index 000000000..d8fd7ca7f --- /dev/null +++ b/gvm/protocols/gmp/__init__.py @@ -0,0 +1,30 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +""" +Protocol implementations for the Greenbone Management Protocol (GMP). + +In most circumstances you will want to use the :class:`GMP` class which +dynamically selects the supported GMP protocol of the remote manager daemon. + +If you need to use a specific GMP version, you can use the :class:`GMPv224` or +:class:`GMPv225` classes. + +* :class:`GMP` - Dynamically select supported GMP protocol of the remote manager daemon. +* :class:`GMPv224` - GMP version 22.4 +* :class:`GMPv225` - GMP version 22.5 +""" + +from ._gmp import GMP +from ._gmp224 import GMPv224 +from ._gmp225 import GMPv225 + +Gmp = GMP # for backwards compatibility + +__all__ = ( + "GMP", + "Gmp", + "GMPv224", + "GMPv225", +) diff --git a/gvm/protocols/gmp/_gmp.py b/gvm/protocols/gmp/_gmp.py new file mode 100644 index 000000000..597f01221 --- /dev/null +++ b/gvm/protocols/gmp/_gmp.py @@ -0,0 +1,118 @@ +# SPDX-FileCopyrightText: 2019-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from types import TracebackType +from typing import Callable, Optional, Type, Union + +from gvm.connections import GvmConnection +from gvm.errors import GvmError +from gvm.protocols.core import Response + +from .._protocol import GvmProtocol, T, str_transform +from ._gmp224 import GMPv224 +from ._gmp225 import GMPv225 +from .requests import Version + +SUPPORTED_GMP_VERSIONS = Union[GMPv224[T], GMPv225[T]] + + +class GMP(GvmProtocol[T]): + """Dynamically select supported GMP protocol of the remote manager daemon. + + Must be used as a `Context Manager + `_ + + Example: + + .. code-block:: python + + from gvm.protocols.gmp import GMP + + with GMP(connection) as gmp: + # gmp can be an instance of gvm.protocols.gmp.GMPv224 or + # gvm.protocols.gmp.GMPv225 depending + # on the supported GMP version of the remote manager daemon + resp = gmp.get_tasks() + + """ + + def __init__( + self, + connection: GvmConnection, + *, + transform: Callable[[Response], T] = str_transform, # type: ignore[assignment] + ): + """ + Create a new GMP instance. + + Args: + connection: Connection to use to talk with the remote daemon. See + :mod:`gvm.connections` for possible connection types. + transform: Optional transform `callable`_ to convert response data. + After each request the callable gets passed the plain response data + which can be used to check the data and/or conversion into different + representations like a xml dom. + + See :mod:`gvm.transforms` for existing transforms. + + .. _callable: + https://docs.python.org/3/library/functions.html#callable + """ + super().__init__(connection, transform=transform) + self._gmp: Optional[SUPPORTED_GMP_VERSIONS] = None + + def determine_remote_gmp_version(self) -> str: + """Determine the supported GMP version of the remote daemon""" + self.connect() + resp = self._send_command(Version.get_version()) + self.disconnect() + + version_el = resp.xml().find("version") + if version_el is None or not version_el.text: + raise GvmError( + "Invalid response from manager daemon while requesting the " + "version information." + ) + + return version_el.text + + def determine_supported_gmp(self) -> SUPPORTED_GMP_VERSIONS: + """Determine supported GMP version of the remote daemon and return a + corresponding GMP class instance + """ + version_str = self.determine_remote_gmp_version().split(".", 1) + major_version = int(version_str[0]) + minor_version = int(version_str[1]) + if major_version == 22 and minor_version == 4: + gmp_class = GMPv224 + elif major_version == 22 and minor_version == 5: + gmp_class = GMPv225 + else: + raise GvmError( + "Remote manager daemon uses an unsupported version of GMP. " + f"The GMP version was {major_version}.{minor_version}" + ) + + return gmp_class(self._connection, transform=self._transform_callable) # type: ignore[arg-type] + + def __enter__(self) -> SUPPORTED_GMP_VERSIONS: # type: ignore[override] + """ + Returns the corresponding GMP class of the supported GMP version of the + remote manager daemon. + """ + self._gmp = self.determine_supported_gmp() + + self._gmp.connect() + + return self._gmp + + def __exit__( + self, + exc_type: Optional[Type[BaseException]], + exc_value: Optional[BaseException], + traceback: Optional[TracebackType], + ) -> None: + if self._gmp: + self._gmp.disconnect() + self._gmp = None diff --git a/gvm/protocols/gmp/_gmp224.py b/gvm/protocols/gmp/_gmp224.py new file mode 100644 index 000000000..b897c304c --- /dev/null +++ b/gvm/protocols/gmp/_gmp224.py @@ -0,0 +1,4296 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +""" +Greenbone Management Protocol (GMP) version 22.4 +""" + +from typing import Iterable, Mapping, Optional, Sequence, Union + +from gvm.utils import SupportsStr, to_dotted_types_dict + +from .._protocol import GvmProtocol, T +from .requests.v224 import ( + Aggregates, + AggregateStatistic, + AlertCondition, + AlertEvent, + AlertMethod, + Alerts, + AliveTest, + Audits, + Authentication, + CertBundAdvisories, + Cpes, + CredentialFormat, + Credentials, + CredentialType, + Cves, + DfnCertAdvisories, + EntityID, + EntityType, + Feed, + FeedType, + Filters, + FilterType, + Groups, + Help, + HelpFormat, + Hosts, + HostsOrdering, + InfoType, + Notes, + Nvts, + OperatingSystems, + Overrides, + Permissions, + PermissionSubjectType, + Policies, + PortLists, + PortRangeType, + ReportFormats, + ReportFormatType, + Reports, + Results, + Roles, + ScanConfigs, + Scanners, + ScannerType, + Schedules, + SecInfo, + Severity, + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, + SortOrder, + SystemReports, + Tags, + Targets, + Tasks, + Tickets, + TicketStatus, + TLSCertificates, + TrashCan, + UserAuthType, + Users, + UserSettings, + Version, + Vulnerabilities, +) + +_TYPE_FIELDS = [ + AggregateStatistic, + AlertCondition, + AlertEvent, + AlertMethod, + AliveTest, + CredentialFormat, + CredentialType, + EntityType, + FeedType, + FilterType, + HostsOrdering, + InfoType, + HelpFormat, + PortRangeType, + PermissionSubjectType, + ReportFormatType, + ScannerType, + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, + SortOrder, + TicketStatus, + UserAuthType, +] + + +class GMPv224(GvmProtocol[T]): + """ + A class implementing the Greenbone Management Protocol (GMP) version 22.4 + + Example: + + .. code-block:: python + + from gvm.protocols.gmp import GMPv224 as GMP + + with GMP(connection) as gmp: + resp = gmp.get_tasks() + """ + + _authenticated = False + + def __init__(self, *args, **kwargs): + """ + Create a new GMPv224 instance. + + Args: + connection: Connection to use to talk with the remote daemon. See + :mod:`gvm.connections` for possible connection types. + transform: Optional transform `callable`_ to convert response data. + After each request the callable gets passed the plain response data + which can be used to check the data and/or conversion into different + representations like a xml dom. + + See :mod:`gvm.transforms` for existing transforms. + + .. _callable: + https://docs.python.org/3/library/functions.html#callable + """ + super().__init__(*args, **kwargs) + self.types = to_dotted_types_dict(_TYPE_FIELDS) + + @staticmethod + def get_protocol_version() -> tuple[int, int]: + """ + Return the supported GMP version as major, minor version tuple + """ + return (22, 4) + + def is_authenticated(self) -> bool: + """Checks if the user is authenticated + + If the user is authenticated privileged GMP commands like get_tasks + may be send to gvmd. + + Returns: + bool: True if an authenticated connection to gvmd has been + established. + """ + return self._authenticated + + def authenticate(self, username: str, password: str) -> T: + """Authenticate to gvmd. + + The generated authenticate command will be send to server. + Afterwards the response is read, transformed and returned. + + Args: + username: Username + password: Password + """ + response = self._send_command( + Authentication.authenticate(username=username, password=password) + ) + + if response.is_success: + self._authenticated = True + + return self._transform(response) + + def describe_auth(self) -> T: + """Describe authentication methods + + Returns a list of all used authentication methods if such a list is + available. + """ + return self._send_and_transform_command(Authentication.describe_auth()) + + def modify_auth( + self, group_name: str, auth_conf_settings: dict[str, str] + ) -> T: + """Modifies an existing auth. + + Args: + group_name: Name of the group to be modified. + auth_conf_settings: The new auth config. + """ + return self._send_and_transform_command( + Authentication.modify_auth(group_name, auth_conf_settings) + ) + + def get_version(self) -> T: + """Get the Greenbone Vulnerability Management Protocol (GMP) version + used by the remote gvmd. + """ + return self._send_and_transform_command(Version.get_version()) + + def clone_port_list(self, port_list_id: EntityID) -> T: + """Clone an existing port list + + Args: + port_list_id: UUID of an existing port list to clone from + """ + return self._send_and_transform_command( + PortLists.clone_port_list(port_list_id) + ) + + def create_port_list( + self, name: str, port_range: str, *, comment: Optional[str] = None + ) -> T: + """Create a new port list + + Args: + name: Name of the new port list + port_range: Port list ranges e.g. `"T: 1-1234"` for tcp port + 1 - 1234 + comment: Comment for the port list + """ + return self._send_and_transform_command( + PortLists.create_port_list(name, port_range, comment=comment) + ) + + def create_port_range( + self, + port_list_id: EntityID, + start: int, + end: int, + port_range_type: Union[str, PortRangeType], + *, + comment: Optional[str] = None, + ) -> T: + """Create new port range + + Args: + port_list_id: UUID of the port list to which to add the range + start: The first port in the range + end: The last port in the range + port_range_type: The type of the ports: TCP, UDP, ... + comment: Comment for the port range + """ + return self._send_and_transform_command( + PortLists.create_port_range( + port_list_id, start, end, port_range_type, comment=comment + ) + ) + + def delete_port_list( + self, port_list_id: EntityID, *, ultimate: bool = False + ) -> T: + """Delete an existing port list + + Args: + port_list_id: UUID of the port list to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + PortLists.delete_port_list(port_list_id, ultimate=ultimate) + ) + + def delete_port_range(self, port_range_id: EntityID) -> T: + """Delete an existing port range + + Args: + port_range_id: UUID of the port range to be deleted. + """ + return self._send_and_transform_command( + PortLists.delete_port_range(port_range_id) + ) + + def get_port_lists( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + targets: Optional[bool] = None, + trash: Optional[bool] = None, + ) -> T: + """Request a list of port lists + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Whether to include full port list details + targets: Whether to include targets using this port list + trash: Whether to get port lists in the trashcan instead + """ + return self._send_and_transform_command( + PortLists.get_port_lists( + filter_string=filter_string, + filter_id=filter_id, + details=details, + targets=targets, + trash=trash, + ) + ) + + def get_port_list(self, port_list_id: EntityID) -> T: + """Request a single port list + + Args: + port_list_id: UUID of an existing port list + """ + return self._send_and_transform_command( + PortLists.get_port_list(port_list_id) + ) + + def modify_port_list( + self, + port_list_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + ) -> T: + """Modify an existing port list. + + Args: + port_list_id: UUID of port list to modify. + name: Name of port list. + comment: Comment on port list. + """ + return self._send_and_transform_command( + PortLists.modify_port_list(port_list_id, comment=comment, name=name) + ) + + def get_aggregates( + self, + resource_type: Union[EntityType, str], + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + sort_criteria: Optional[ + Iterable[dict[str, Union[str, SortOrder, AggregateStatistic]]] + ] = None, + data_columns: Optional[Iterable[str]] = None, + group_column: Optional[str] = None, + subgroup_column: Optional[str] = None, + text_columns: Optional[Iterable[str]] = None, + first_group: Optional[int] = None, + max_groups: Optional[int] = None, + mode: Optional[int] = None, + **kwargs, + ) -> T: + """Request aggregated information on a resource / entity type + + Additional arguments can be set via the kwargs parameter for backward + compatibility with older versions of python-gvm, but are not validated. + + Args: + resource_type: The entity type to gather data from + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + sort_criteria: List of sort criteria (dicts that can contain + a field, stat and order) + data_columns: List of fields to aggregate data from + group_column: The field to group the entities by + subgroup_column: The field to further group the entities + inside groups by + text_columns: List of simple text columns which no statistics + are calculated for + first_group: The index of the first aggregate group to return + max_groups: The maximum number of aggregate groups to return, + -1 for all + mode: Special mode for aggregation + """ + return self._send_and_transform_command( + Aggregates.get_aggregates( + resource_type, + filter_string=filter_string, + filter_id=filter_id, + sort_criteria=sort_criteria, + data_columns=data_columns, + group_column=group_column, + subgroup_column=subgroup_column, + text_columns=text_columns, + first_group=first_group, + max_groups=max_groups, + mode=mode, + **kwargs, + ) + ) + + def get_feeds(self) -> T: + """Request the list of feeds""" + return self._send_and_transform_command(Feed.get_feeds()) + + def get_feed(self, feed_type: Union[FeedType, str]) -> T: + """Request a single feed + + Args: + feed_type: Type of single feed to get: NVT, CERT or SCAP + """ + return self._send_and_transform_command(Feed.get_feed(feed_type)) + + def help( + self, + *, + help_format: Optional[Union[HelpFormat, str]] = None, + brief: Optional[bool] = None, + ) -> T: + """Get the help text + + Args: + help_format: Format of of the help: + "html", "rnc", "text" or "xml + brief: If True help is brief + """ + return self._send_and_transform_command( + Help.help(help_format=help_format, brief=brief) + ) + + def get_system_reports( + self, + *, + name: Optional[str] = None, + duration: Optional[int] = None, + start_time: Optional[str] = None, + end_time: Optional[str] = None, + brief: Optional[bool] = None, + slave_id: Optional[EntityID] = None, + ) -> T: + """Request a list of system reports + + Args: + name: A string describing the required system report + duration: The number of seconds into the past that the system report + should include + start_time: The start of the time interval the system report should + include in ISO time format + end_time: The end of the time interval the system report should + include in ISO time format + brief: Whether to include the actual system reports + slave_id: UUID of GMP scanner from which to get the system reports + """ + return self._send_and_transform_command( + SystemReports.get_system_reports( + name=name, + duration=duration, + start_time=start_time, + end_time=end_time, + brief=brief, + slave_id=slave_id, + ) + ) + + def empty_trashcan(self) -> T: + """Empty the trashcan + + Remove all entities from the trashcan. **Attention:** this command can + not be reverted + """ + return self._send_and_transform_command(TrashCan.empty_trashcan()) + + def restore_from_trashcan(self, entity_id: EntityID) -> T: + """Restore an entity from the trashcan + + Args: + entity_id: ID of the entity to be restored from the trashcan + """ + return self._send_and_transform_command( + TrashCan.restore_from_trashcan(entity_id) + ) + + def get_user_settings(self, *, filter_string: Optional[str] = None) -> T: + """Request a list of user settings + + Args: + filter_string: Filter term to use for the query + """ + return self._send_and_transform_command( + UserSettings.get_user_settings(filter_string=filter_string) + ) + + def get_user_setting(self, setting_id: EntityID) -> T: + """Request a single user setting + + Args: + setting_id: UUID of an existing setting + """ + return self._send_and_transform_command( + UserSettings.get_user_setting(setting_id) + ) + + def modify_user_setting( + self, + *, + setting_id: Optional[EntityID] = None, + name: Optional[str] = None, + value: Optional[str] = None, + ) -> T: + """Modifies an existing user setting. + + Args: + setting_id: UUID of the setting to be changed. + name: The name of the setting. Either setting_id or name must be + passed. + value: The value of the setting. + """ + return self._send_and_transform_command( + UserSettings.modify_user_setting( + setting_id=setting_id, name=name, value=value + ) + ) + + def clone_scan_config(self, config_id: EntityID) -> T: + """Clone a scan config from an existing one + + Args: + config_id: UUID of the existing scan config + """ + return self._send_and_transform_command( + ScanConfigs.clone_scan_config(config_id) + ) + + def create_scan_config( + self, + config_id: EntityID, + name: str, + *, + comment: Optional[str] = None, + ) -> T: + """Create a new scan config + + Args: + config_id: UUID of the existing scan config + name: Name of the new scan config + comment: A comment on the config + """ + return self._send_and_transform_command( + ScanConfigs.create_scan_config(config_id, name, comment=comment) + ) + + def delete_scan_config( + self, config_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing config + + Args: + config_id: UUID of the config to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + ScanConfigs.delete_scan_config(config_id, ultimate=ultimate) + ) + + def get_scan_configs( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + details: Optional[bool] = None, + families: Optional[bool] = None, + preferences: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> T: + """Request a list of scan configs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan scan configs instead + details: Whether to get config families, preferences, nvt selectors + and tasks. + families: Whether to include the families if no details are + requested + preferences: Whether to include the preferences if no details are + requested + tasks: Whether to get tasks using this config + """ + return self._send_and_transform_command( + ScanConfigs.get_scan_configs( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + details=details, + families=families, + preferences=preferences, + tasks=tasks, + ) + ) + + def get_scan_config( + self, config_id: EntityID, *, tasks: Optional[bool] = None + ) -> T: + """Request a single scan config + + Args: + config_id: UUID of an existing scan config + tasks: Whether to get tasks using this config + """ + return self._send_and_transform_command( + ScanConfigs.get_scan_config(config_id, tasks=tasks) + ) + + def get_scan_config_preferences( + self, + *, + nvt_oid: Optional[str] = None, + config_id: Optional[EntityID] = None, + ) -> T: + """Request a list of scan_config preferences + + When the command includes a config_id attribute, the preference element + includes the preference name, type and value, and the NVT to which the + preference applies. + If the command includes a config_id and an nvt_oid, the preferences for + the given nvt in the config will be shown. + + Args: + nvt_oid: OID of nvt + config_id: UUID of scan config of which to show preference values + """ + return self._send_and_transform_command( + ScanConfigs.get_scan_config_preferences( + nvt_oid=nvt_oid, config_id=config_id + ) + ) + + def get_scan_config_preference( + self, + name: str, + *, + nvt_oid: Optional[str] = None, + config_id: Optional[EntityID] = None, + ) -> T: + """Request a nvt preference + + Args: + name: name of a particular preference + nvt_oid: OID of nvt + config_id: UUID of scan config of which to show preference values + """ + return self._send_and_transform_command( + ScanConfigs.get_scan_config_preference( + name, nvt_oid=nvt_oid, config_id=config_id + ) + ) + + def import_scan_config(self, config: str) -> T: + """Import a scan config from XML + + Args: + config: Scan Config XML as string to import. This XML must + contain a :code:`` root element. + """ + return self._send_and_transform_command( + ScanConfigs.import_scan_config(config) + ) + + def modify_scan_config_set_nvt_preference( + self, + config_id: EntityID, + name: str, + nvt_oid: str, + *, + value: Optional[str] = None, + ) -> T: + """Modifies the nvt preferences of an existing scan config. + + Args: + config_id: UUID of scan config to modify. + name: Name for nvt preference to change. + nvt_oid: OID of the NVT associated with preference to modify + value: New value for the preference. None to delete the preference + and to use the default instead. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_nvt_preference( + config_id, name, nvt_oid, value=value + ) + ) + + def modify_scan_config_set_name(self, config_id: EntityID, name: str) -> T: + """Modifies the name of an existing scan config + + Args: + config_id: UUID of scan config to modify. + name: New name for the config. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_name(config_id, name) + ) + + def modify_scan_config_set_comment( + self, config_id: EntityID, *, comment: Optional[str] = None + ) -> T: + """Modifies the comment of an existing scan config + + Args: + config_id: UUID of scan config to modify. + comment: Comment to set on a config. Default is an + empty comment and the previous comment will be + removed. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_comment( + config_id, comment=comment + ) + ) + + def modify_scan_config_set_scanner_preference( + self, + config_id: EntityID, + name: str, + *, + value: Optional[str] = None, + ) -> T: + """Modifies the scanner preferences of an existing scan config + + Args: + config_id: UUID of scan config to modify. + name: Name of the scanner preference to change + value: New value for the preference. None to delete the preference + and to use the default instead. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_scanner_preference( + config_id, name, value=value + ) + ) + + def modify_scan_config_set_nvt_selection( + self, + config_id: EntityID, + family: str, + nvt_oids: Union[tuple[str], list[str]], + ) -> T: + """Modifies the selected nvts of an existing scan config + + The manager updates the given family in the config to include only the + given NVTs. + + Arguments: + config_id: UUID of scan config to modify. + family: Name of the NVT family to include NVTs from + nvt_oids: List of NVTs to select for the family. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_nvt_selection( + config_id, family, nvt_oids + ) + ) + + def modify_scan_config_set_family_selection( + self, + config_id: EntityID, + families: list[tuple[str, bool, bool]], + *, + auto_add_new_families: Optional[bool] = True, + ) -> T: + """ + Selected the NVTs of a scan config at a family level. + + Args: + config_id: UUID of scan config to modify. + families: A list of tuples (str, bool, bool): + str: the name of the NVT family selected, + bool: add new NVTs to the family automatically, + bool: include all NVTs from the family + auto_add_new_families: Whether new families should be added to the + scan config automatically. Default: True. + """ + return self._send_and_transform_command( + ScanConfigs.modify_scan_config_set_family_selection( + config_id, families, auto_add_new_families=auto_add_new_families + ) + ) + + def create_scanner( + self, + name: str, + host: str, + port: Union[str, int], + scanner_type: ScannerType, + credential_id: str, + *, + ca_pub: Optional[str] = None, + comment: Optional[str] = None, + ) -> T: + """Create a new scanner + + Args: + name: Name of the new scanner + host: Hostname or IP address of the scanner + port: Port of the scanner + scanner_type: Type of the scanner + credential_id: UUID of client certificate credential for the + scanner + ca_pub: Certificate of CA to verify scanner certificate + comment: Comment for the scanner + """ + return self._send_and_transform_command( + Scanners.create_scanner( + name, + host, + port, + scanner_type, + credential_id, + ca_pub=ca_pub, + comment=comment, + ) + ) + + def modify_scanner( + self, + scanner_id: EntityID, + *, + name: Optional[str] = None, + host: Optional[str] = None, + port: Optional[int] = None, + scanner_type: Optional[ScannerType] = None, + credential_id: Optional[EntityID] = None, + ca_pub: Optional[str] = None, + comment: Optional[str] = None, + ) -> T: + """Modify an existing scanner + + Args: + scanner_id: UUID of the scanner to modify + name: New name of the scanner + host: New hostname or IP address of the scanner + port: New port of the scanner + scanner_type: New type of the scanner + credential_id: New UUID of client certificate credential for the + scanner + ca_pub: New certificate of CA to verify scanner certificate + comment: New comment for the scanner + """ + return self._send_and_transform_command( + Scanners.modify_scanner( + scanner_id, + name=name, + host=host, + port=port, + scanner_type=scanner_type, + credential_id=credential_id, + ca_pub=ca_pub, + comment=comment, + ) + ) + + def get_scanners( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of scanners + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan scanners instead + details: Whether to include extra details like tasks using this + scanner + """ + return self._send_and_transform_command( + Scanners.get_scanners( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + details=details, + ) + ) + + def get_scanner(self, scanner_id: EntityID) -> T: + """Request a single scanner + + Args: + scanner_id: UUID of an existing scanner + """ + return self._send_and_transform_command( + Scanners.get_scanner(scanner_id) + ) + + def verify_scanner(self, scanner_id: EntityID) -> T: + """Verify an existing scanner + + Args: + scanner_id: UUID of an existing scanner + """ + return self._send_and_transform_command( + Scanners.verify_scanner(scanner_id) + ) + + def clone_scanner(self, scanner_id: EntityID) -> T: + """Clone an existing scanner + + Args: + scanner_id: UUID of an existing scanner + """ + return self._send_and_transform_command( + Scanners.clone_scanner(scanner_id) + ) + + def delete_scanner( + self, scanner_id: EntityID, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing scanner + + Args: + scanner_id: UUID of an existing scanner + """ + return self._send_and_transform_command( + Scanners.delete_scanner(scanner_id, ultimate=ultimate) + ) + + def create_user( + self, + name: str, + *, + password: Optional[str] = None, + hosts: Optional[list[str]] = None, + hosts_allow: Optional[bool] = False, + role_ids: Optional[list[EntityID]] = None, + ) -> T: + """Create a new user + + Args: + name: Name of the user + password: Password of the user + hosts: A list of host addresses (IPs, DNS names) + hosts_allow: If True allow only access to passed hosts otherwise + deny access. Default is False for deny hosts. + role_ids: A list of role UUIDs for the user + """ + return self._send_and_transform_command( + Users.create_user( + name, + password=password, + hosts=hosts, + hosts_allow=hosts_allow, + role_ids=role_ids, + ) + ) + + def modify_user( + self, + user_id: EntityID, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + password: Optional[str] = None, + auth_source: Optional[UserAuthType] = None, + role_ids: Optional[list[EntityID]] = None, + hosts: Optional[list[str]] = None, + hosts_allow: Optional[bool] = False, + group_ids: Optional[list[EntityID]] = None, + ) -> T: + """Modify an existing user. + + Most of the fields need to be supplied + for changing a single field even if no change is wanted for those. + Else empty values are inserted for the missing fields instead. + + Args: + user_id: UUID of the user to be modified. + name: The new name for the user. + comment: Comment on the user. + password: The password for the user. + auth_source: Source allowed for authentication for this user. + roles_id: List of roles UUIDs for the user. + hosts: User access rules: List of hosts. + hosts_allow: Defines how the hosts list is to be interpreted. + If False (default) the list is treated as a deny list. + All hosts are allowed by default except those provided by + the hosts parameter. If True the list is treated as a + allow list. All hosts are denied by default except those + provided by the hosts parameter. + group_ids: List of group UUIDs for the user. + """ + return self._send_and_transform_command( + Users.modify_user( + user_id, + name=name, + comment=comment, + password=password, + auth_source=auth_source, + role_ids=role_ids, + hosts=hosts, + hosts_allow=hosts_allow, + group_ids=group_ids, + ) + ) + + def clone_user(self, user_id: EntityID) -> T: + """Clone an existing user. + + Args: + user_id: UUID of the user to be cloned. + """ + return self._send_and_transform_command(Users.clone_user(user_id)) + + def delete_user( + self, + user_id: Optional[EntityID] = None, + *, + name: Optional[str] = None, + inheritor_id: Optional[EntityID] = None, + inheritor_name: Optional[str] = None, + ) -> T: + """Delete an existing user + + Either user_id or name must be passed. + + Args: + user_id: UUID of the task to be deleted. + name: The name of the user to be deleted. + inheritor_id: The UUID of the inheriting user or "self". Overrides + inheritor_name. + inheritor_name: The name of the inheriting user. + """ + return self._send_and_transform_command( + Users.delete_user( + user_id=user_id, + name=name, + inheritor_id=inheritor_id, + inheritor_name=inheritor_name, + ) + ) + + def get_users( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + ) -> T: + """Request a list of users + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + """ + return self._send_and_transform_command( + Users.get_users(filter_string=filter_string, filter_id=filter_id) + ) + + def get_user(self, user_id: EntityID) -> T: + """Request a single user + + Args: + user_id: UUID of the user to be requested. + """ + return self._send_and_transform_command(Users.get_user(user_id)) + + def create_note( + self, + text: str, + nvt_oid: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> T: + """Create a new note + + Args: + text: Text of the new note + nvt_id: OID of the nvt to which note applies + days_active: Days note will be active. -1 on + always, 0 off + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: UUID of a result to which note applies + severity: Severity to which note applies + task_id: UUID of task to which note applies + """ + return self._send_and_transform_command( + Notes.create_note( + text, + nvt_oid, + days_active=days_active, + hosts=hosts, + port=port, + result_id=result_id, + severity=severity, + task_id=task_id, + ) + ) + + def modify_note( + self, + note_id: EntityID, + text: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> T: + """Modify a note + + Args: + note_id: The UUID of the note to modify + text: Text of the note + days_active: Days note will be active. -1 on always, 0 off + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: UUID of a result to which note applies + severity: Severity to which note applies + task_id: UUID of task to which note applies + """ + return self._send_and_transform_command( + Notes.modify_note( + note_id, + text, + days_active=days_active, + hosts=hosts, + port=port, + result_id=result_id, + severity=severity, + task_id=task_id, + ) + ) + + def clone_note(self, note_id: EntityID) -> T: + """Clone an existing note + + Args: + note_id: UUID of an existing note to clone from + """ + return self._send_and_transform_command(Notes.clone_note(note_id)) + + def delete_note( + self, note_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing note + + Args: + note_id: UUID of the note to be deleted. + ultimate: Whether to remove entirely or to the trashcan. + """ + return self._send_and_transform_command( + Notes.delete_note(note_id, ultimate=ultimate) + ) + + def get_notes( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + result: Optional[bool] = None, + ) -> T: + """Request a list of notes + + Args: + filter_string: Filter notes by a string + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Add info about connected results and tasks + result: Return the details of possible connected results. + """ + return self._send_and_transform_command( + Notes.get_notes( + filter_string=filter_string, + filter_id=filter_id, + details=details, + result=result, + ) + ) + + def get_note(self, note_id: EntityID) -> T: + """Request a single note + + Arguments: + note_id: UUID of an existing note + """ + return self._send_and_transform_command(Notes.get_note(note_id)) + + def create_override( + self, + text: str, + nvt_oid: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + new_severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> T: + """Create a new override + + Args: + text: Text of the new override + nvt_id: OID of the nvt to which override applies + days_active: Days override will be active. -1 on always, 0 off + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: UUID of a result to which override applies + severity: Severity to which override applies + new_severity: New severity for result + task_id: UUID of task to which override applies + """ + return self._send_and_transform_command( + Overrides.create_override( + text, + nvt_oid, + days_active=days_active, + hosts=hosts, + port=port, + result_id=result_id, + severity=severity, + new_severity=new_severity, + task_id=task_id, + ) + ) + + def modify_override( + self, + override_id: EntityID, + text: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + new_severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> T: + """Modify an existing override. + + Args: + override_id: UUID of override to modify. + text: The text of the override. + days_active: Days override will be active. -1 on always, + 0 off. + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: Result to which override applies. + severity: Severity to which override applies. + new_severity: New severity score for result. + task_id: Task to which override applies. + """ + return self._send_and_transform_command( + Overrides.modify_override( + override_id, + text, + days_active=days_active, + hosts=hosts, + port=port, + result_id=result_id, + severity=severity, + new_severity=new_severity, + task_id=task_id, + ) + ) + + def clone_override(self, override_id: EntityID) -> T: + """Clone an existing override + + Args: + override_id: UUID of an existing override to clone from + """ + return self._send_and_transform_command( + Overrides.clone_override(override_id) + ) + + def delete_override( + self, override_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing override + + Args: + override_id: UUID of an existing override to delete + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Overrides.delete_override(override_id, ultimate=ultimate) + ) + + def get_overrides( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + result: Optional[bool] = None, + ) -> T: + """Request a list of overrides + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Whether to include full details + result: Whether to include results using the override + """ + return self._send_and_transform_command( + Overrides.get_overrides( + filter_string=filter_string, + filter_id=filter_id, + details=details, + result=result, + ) + ) + + def get_override(self, override_id: EntityID) -> T: + """Request a single override + + Args: + override_id: UUID of an existing override + """ + return self._send_and_transform_command( + Overrides.get_override(override_id) + ) + + def create_target( + self, + name: str, + *, + asset_hosts_filter: Optional[str] = None, + hosts: Optional[list[str]] = None, + comment: Optional[str] = None, + exclude_hosts: Optional[list[str]] = None, + ssh_credential_id: Optional[EntityID] = None, + ssh_credential_port: Optional[Union[int, str]] = None, + smb_credential_id: Optional[EntityID] = None, + esxi_credential_id: Optional[EntityID] = None, + snmp_credential_id: Optional[EntityID] = None, + alive_test: Optional[Union[str, AliveTest]] = None, + allow_simultaneous_ips: Optional[bool] = None, + reverse_lookup_only: Optional[bool] = None, + reverse_lookup_unify: Optional[bool] = None, + port_range: Optional[str] = None, + port_list_id: Optional[EntityID] = None, + ) -> T: + """Create a new target + + Args: + name: Name of the target + asset_hosts_filter: Filter to select target host from assets hosts + hosts: List of hosts addresses to scan + exclude_hosts: List of hosts addresses to exclude from scan + comment: Comment for the target + ssh_credential_id: UUID of a ssh credential to use on target + ssh_credential_port: The port to use for ssh credential + smb_credential_id: UUID of a smb credential to use on target + snmp_credential_id: UUID of a snmp credential to use on target + esxi_credential_id: UUID of a esxi credential to use on target + alive_test: Which alive test to use + allow_simultaneous_ips: Whether to scan multiple IPs of the + same host simultaneously + reverse_lookup_only: Whether to scan only hosts that have names + reverse_lookup_unify: Whether to scan only one IP when multiple IPs + have the same name. + port_range: Port range for the target + port_list_id: UUID of the port list to use on target + """ + return self._send_and_transform_command( + Targets.create_target( + name, + asset_hosts_filter=asset_hosts_filter, + hosts=hosts, + comment=comment, + exclude_hosts=exclude_hosts, + ssh_credential_id=ssh_credential_id, + ssh_credential_port=ssh_credential_port, + smb_credential_id=smb_credential_id, + esxi_credential_id=esxi_credential_id, + snmp_credential_id=snmp_credential_id, + alive_test=alive_test, + allow_simultaneous_ips=allow_simultaneous_ips, + reverse_lookup_only=reverse_lookup_only, + reverse_lookup_unify=reverse_lookup_unify, + port_range=port_range, + port_list_id=port_list_id, + ) + ) + + def modify_target( + self, + target_id: EntityID, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + hosts: Optional[list[str]] = None, + exclude_hosts: Optional[list[str]] = None, + ssh_credential_id: Optional[EntityID] = None, + ssh_credential_port: Optional[Union[str, int]] = None, + smb_credential_id: Optional[EntityID] = None, + esxi_credential_id: Optional[EntityID] = None, + snmp_credential_id: Optional[EntityID] = None, + alive_test: Optional[Union[AliveTest, str]] = None, + allow_simultaneous_ips: Optional[bool] = None, + reverse_lookup_only: Optional[bool] = None, + reverse_lookup_unify: Optional[bool] = None, + port_list_id: Optional[EntityID] = None, + ) -> T: + """Modify an existing target. + + Args: + target_id: UUID of target to modify. + comment: Comment on target. + name: Name of target. + hosts: List of target hosts. + exclude_hosts: A list of hosts to exclude. + ssh_credential_id: UUID of SSH credential to use on target. + ssh_credential_port: The port to use for ssh credential + smb_credential_id: UUID of SMB credential to use on target. + esxi_credential_id: UUID of ESXi credential to use on target. + snmp_credential_id: UUID of SNMP credential to use on target. + port_list_id: UUID of port list describing ports to scan. + alive_test: Which alive tests to use. + allow_simultaneous_ips: Whether to scan multiple IPs of the + same host simultaneously + reverse_lookup_only: Whether to scan only hosts that have names. + reverse_lookup_unify: Whether to scan only one IP when multiple IPs + have the same name. + """ + return self._send_and_transform_command( + Targets.modify_target( + target_id, + name=name, + comment=comment, + hosts=hosts, + exclude_hosts=exclude_hosts, + ssh_credential_id=ssh_credential_id, + ssh_credential_port=ssh_credential_port, + smb_credential_id=smb_credential_id, + esxi_credential_id=esxi_credential_id, + snmp_credential_id=snmp_credential_id, + alive_test=alive_test, + allow_simultaneous_ips=allow_simultaneous_ips, + reverse_lookup_only=reverse_lookup_only, + reverse_lookup_unify=reverse_lookup_unify, + port_list_id=port_list_id, + ) + ) + + def clone_target(self, target_id: EntityID) -> T: + """Clone an existing target. + + Args: + target_id: UUID of an existing target to clone. + """ + return self._send_and_transform_command(Targets.clone_target(target_id)) + + def delete_target( + self, target_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing target. + + Args: + target_id: UUID of an existing target to delete. + ultimate: Whether to remove entirely or to the trashcan. + """ + return self._send_and_transform_command( + Targets.delete_target(target_id, ultimate=ultimate) + ) + + def get_target( + self, target_id: EntityID, *, tasks: Optional[bool] = None + ) -> T: + """Request a single target. + + Args: + target_id: UUID of the target to request. + tasks: Whether to include list of tasks that use the target + """ + return self._send_and_transform_command( + Targets.get_target(target_id, tasks=tasks) + ) + + def get_targets( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> T: + """Request a list of targets. + + Args: + filter_string: Filter term to use for the query. + filter_id: UUID of an existing filter to use for the query. + trash: Whether to include targets in the trashcan. + tasks: Whether to include list of tasks that use the target. + """ + return self._send_and_transform_command( + Targets.get_targets( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + tasks=tasks, + ) + ) + + def create_alert( + self, + name: str, + condition: AlertCondition, + event: AlertEvent, + method: AlertMethod, + *, + method_data: Optional[dict[str, str]] = None, + event_data: Optional[dict[str, str]] = None, + condition_data: Optional[dict[str, str]] = None, + filter_id: Optional[EntityID] = None, + comment: Optional[str] = None, + ) -> T: + """Create a new alert + + Args: + name: Name of the new Alert + condition: The condition that must be satisfied for the alert + to occur; if the event is either 'Updated SecInfo arrived' or + 'New SecInfo arrived', condition must be 'Always'. Otherwise, + condition can also be on of 'Severity at least', 'Filter count + changed' or 'Filter count at least'. + event: The event that must happen for the alert to occur, one + of 'Task run status changed', 'Updated SecInfo arrived' or 'New + SecInfo arrived' + method: The method by which the user is alerted, one of 'SCP', + 'Send', 'SMB', 'SNMP', 'Syslog' or 'Email'; if the event is + neither 'Updated SecInfo arrived' nor 'New SecInfo arrived', + method can also be one of 'Start Task', 'HTTP Get', 'Sourcefire + Connector' or 'verinice Connector'. + condition_data: Data that defines the condition + event_data: Data that defines the event + method_data: Data that defines the method + filter_id: Filter to apply when executing alert + comment: Comment for the alert + """ + return self._send_and_transform_command( + Alerts.create_alert( + name, + condition, + event, + method, + method_data=method_data, + event_data=event_data, + condition_data=condition_data, + filter_id=filter_id, + comment=comment, + ) + ) + + def modify_alert( + self, + alert_id: EntityID, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + filter_id: Optional[EntityID] = None, + event: Optional[Union[AlertEvent, str]] = None, + event_data: Optional[dict] = None, + condition: Optional[Union[AlertCondition, str]] = None, + condition_data: Optional[dict[str, str]] = None, + method: Optional[Union[AlertMethod, str]] = None, + method_data: Optional[dict[str, str]] = None, + ) -> T: + """Modify an existing alert. + + Args: + alert_id: UUID of the alert to be modified. + name: Name of the Alert. + condition: The condition that must be satisfied for the alert to + occur. If the event is either 'Updated SecInfo + arrived' or 'New SecInfo arrived', condition must be 'Always'. + Otherwise, condition can also be on of 'Severity at least', + 'Filter count changed' or 'Filter count at least'. + condition_data: Data that defines the condition + event: The event that must happen for the alert to occur, one of + 'Task run status changed', 'Updated SecInfo arrived' or + 'New SecInfo arrived' + event_data: Data that defines the event + method: The method by which the user is alerted, one of 'SCP', + 'Send', 'SMB', 'SNMP', 'Syslog' or 'Email'; + if the event is neither 'Updated SecInfo arrived' nor + 'New SecInfo arrived', method can also be one of 'Start Task', + 'HTTP Get', 'Sourcefire Connector' or 'verinice Connector'. + method_data: Data that defines the method + filter_id: Filter to apply when executing alert + comment: Comment for the alert + """ + return self._send_and_transform_command( + Alerts.modify_alert( + alert_id, + name=name, + comment=comment, + filter_id=filter_id, + event=event, + event_data=event_data, + condition=condition, + condition_data=condition_data, + method=method, + method_data=method_data, + ) + ) + + def clone_alert(self, alert_id: EntityID) -> T: + """Clone an existing alert + + Args: + alert_id: UUID of the alert to clone from + """ + return self._send_and_transform_command(Alerts.clone_alert(alert_id)) + + def delete_alert( + self, alert_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing alert + + Args: + alert_id: UUID of the alert to delete + ultimate: Whether to remove entirely or to the trashcan. + """ + return self._send_and_transform_command( + Alerts.delete_alert(alert_id, ultimate=ultimate) + ) + + def test_alert(self, alert_id: EntityID) -> T: + """Run an alert + + Invoke a test run of an alert + + Args: + alert_id: UUID of the alert to be tested + """ + return self._send_and_transform_command(Alerts.test_alert(alert_id)) + + def trigger_alert( + self, + alert_id: EntityID, + report_id: EntityID, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + report_format_id: Optional[Union[EntityID, ReportFormatType]] = None, + delta_report_id: Optional[EntityID] = None, + ) -> T: + """Run an alert by ignoring its event and conditions + + The alert is triggered to run immediately with the provided filtered + report by ignoring the even and condition settings. + + Args: + alert_id: UUID of the alert to be run + report_id: UUID of the report to be provided to the alert + filter: Filter term to use to filter results in the report + filter_id: UUID of filter to use to filter results in the report + report_format_id: UUID of report format to use or ReportFormatType (enum) + delta_report_id: UUID of an existing report to compare report to. + """ + return self._send_and_transform_command( + Alerts.trigger_alert( + alert_id, + report_id, + filter_string=filter_string, + filter_id=filter_id, + report_format_id=report_format_id, + delta_report_id=delta_report_id, + ) + ) + + def get_alerts( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> T: + """Request a list of alerts + + Args: + filter: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: True to request the alerts in the trashcan + tasks: Whether to include the tasks using the alerts + """ + return self._send_and_transform_command( + Alerts.get_alerts( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + tasks=tasks, + ) + ) + + def get_alert( + self, alert_id: EntityID, *, tasks: Optional[bool] = None + ) -> T: + """Request a single alert + + Arguments: + alert_id: UUID of an existing alert + tasks: Whether to include the tasks using the alert + """ + return self._send_and_transform_command( + Alerts.get_alert(alert_id, tasks=tasks) + ) + + def create_audit( + self, + name: str, + policy_id: EntityID, + target_id: EntityID, + scanner_id: EntityID, + *, + alterable: Optional[bool] = None, + hosts_ordering: Optional[Union[HostsOrdering, str]] = None, + schedule_id: Optional[str] = None, + alert_ids: Optional[list[EntityID]] = None, + comment: Optional[str] = None, + schedule_periods: Optional[int] = None, + observers: Optional[list[EntityID]] = None, + preferences: Optional[dict[str, str]] = None, + ) -> T: + """Create a new audit + + Args: + name: Name of the new audit + policy_id: UUID of policy to use by the audit + target_id: UUID of target to be scanned + scanner_id: UUID of scanner to use for scanning the target + comment: Comment for the audit + alterable: Whether the task should be alterable + alert_ids: List of UUIDs for alerts to be applied to the audit + hosts_ordering: The order hosts are scanned in + schedule_id: UUID of a schedule when the audit should be run. + schedule_periods: A limit to the number of times the audit will be + scheduled, or 0 for no limit + observers: List of names or ids of users which should be allowed to + observe this audit + preferences: Name/Value pairs of scanner preferences. + """ + return self._send_and_transform_command( + Audits.create_audit( + name, + policy_id, + target_id, + scanner_id, + alterable=alterable, + hosts_ordering=hosts_ordering, + schedule_id=schedule_id, + alert_ids=alert_ids, + comment=comment, + schedule_periods=schedule_periods, + observers=observers, + preferences=preferences, + ) + ) + + def modify_audit( + self, + audit_id: EntityID, + *, + name: Optional[str] = None, + policy_id: Optional[EntityID] = None, + target_id: Optional[EntityID] = None, + scanner_id: Optional[EntityID] = None, + alterable: Optional[bool] = None, + hosts_ordering: Optional[Union[str, HostsOrdering]] = None, + schedule_id: Optional[EntityID] = None, + schedule_periods: Optional[int] = None, + comment: Optional[str] = None, + alert_ids: Optional[list[EntityID]] = None, + observers: Optional[list[EntityID]] = None, + preferences: Optional[dict[str, str]] = None, + ) -> T: + """Modifies an existing audit. + + Args: + audit_id: UUID of audit to modify. + name: The name of the audit. + policy_id: UUID of policy to use by the audit + target_id: UUID of target to be scanned + scanner_id: UUID of scanner to use for scanning the target + comment: The comment on the audit. + alert_ids: List of UUIDs for alerts to be applied to the audit + hosts_ordering: The order hosts are scanned in + schedule_id: UUID of a schedule when the audit should be run. + schedule_periods: A limit to the number of times the audit will be + scheduled, or 0 for no limit. + observers: List of names or ids of users which should be allowed to + observe this audit + preferences: Name/Value pairs of scanner preferences. + """ + return self._send_and_transform_command( + Audits.modify_audit( + audit_id, + name=name, + policy_id=policy_id, + target_id=target_id, + scanner_id=scanner_id, + alterable=alterable, + hosts_ordering=hosts_ordering, + schedule_id=schedule_id, + alert_ids=alert_ids, + comment=comment, + schedule_periods=schedule_periods, + observers=observers, + preferences=preferences, + ) + ) + + def clone_audit(self, audit_id: EntityID) -> T: + """Clone an existing audit + + Args: + audit_id: UUID of the audit to clone + """ + return self._send_and_transform_command(Audits.clone_audit(audit_id)) + + def delete_audit( + self, audit_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing audit + + Args: + audit_id: UUID of the audit to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Audits.delete_audit(audit_id, ultimate=ultimate) + ) + + def get_audits( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + details: Optional[bool] = None, + schedules_only: Optional[bool] = None, + ) -> T: + """Request a list of audits + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan audits instead + details: Whether to include full audit details + schedules_only: Whether to only include id, name and schedule + details + """ + return self._send_and_transform_command( + Audits.get_audits( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + details=details, + schedules_only=schedules_only, + ) + ) + + def get_audit(self, audit_id: EntityID) -> T: + """Request a single audit + + Args: + audit_id: UUID of an existing audit + """ + return self._send_and_transform_command(Audits.get_audit(audit_id)) + + def resume_audit(self, audit_id: EntityID) -> T: + """Resume an existing stopped audit + + Args: + audit_id: UUID of the audit to be resumed + """ + return self._send_and_transform_command(Audits.resume_audit(audit_id)) + + def start_audit(self, audit_id: EntityID) -> T: + """Start an existing audit + + Args: + audit_id: UUID of the audit to be started + """ + return self._send_and_transform_command(Audits.start_audit(audit_id)) + + def stop_audit(self, audit_id: EntityID) -> T: + """Stop an existing running audit + + Args: + audit_id: UUID of the audit to be stopped + """ + return self._send_and_transform_command(Audits.stop_audit(audit_id)) + + def clone_credential(self, credential_id: EntityID) -> T: + """Clone an existing credential + + Args: + credential_id: UUID of the credential to clone + """ + return self._send_and_transform_command( + Credentials.clone_credential(credential_id) + ) + + def create_credential( + self, + name: str, + credential_type: Union[CredentialType, str], + *, + comment: Optional[str] = None, + allow_insecure: Optional[bool] = None, + certificate: Optional[str] = None, + key_phrase: Optional[str] = None, + private_key: Optional[str] = None, + login: Optional[str] = None, + password: Optional[str] = None, + auth_algorithm: Optional[Union[SnmpAuthAlgorithm, str]] = None, + community: Optional[str] = None, + privacy_algorithm: Optional[Union[SnmpPrivacyAlgorithm, str]] = None, + privacy_password: Optional[str] = None, + public_key: Optional[str] = None, + ) -> T: + """Create a new credential + + Create a new credential e.g. to be used in the method of an alert. + + Currently the following credential types are supported: + + - Username + Password + - Username + SSH-Key + - Client Certificates + - SNMPv1 or SNMPv2c protocol + - S/MIME Certificate + - OpenPGP Key + - Password only + + Args: + name: Name of the new credential + credential_type: The credential type. + comment: Comment for the credential + allow_insecure: Whether to allow insecure use of the credential + certificate: Certificate for the credential. + Required for client-certificate and smime credential types. + key_phrase: Key passphrase for the private key. + Used for the username+ssh-key credential type. + private_key: Private key to use for login. Required + for usk credential type. Also used for the cc credential type. + The supported key types (dsa, rsa, ecdsa, ...) and formats (PEM, + PKC#12, OpenSSL, ...) depend on your installed GnuTLS version. + login: Username for the credential. Required for username+password, + username+ssh-key and snmp credential type. + password: Password for the credential. Used for username+password + and snmp credential types. + community: The SNMP community + auth_algorithm: The SNMP authentication algorithm. Required for snmp + credential type. + privacy_algorithm: The SNMP privacy algorithm + privacy_password: The SNMP privacy password + public_key: PGP public key in *armor* plain text format. Required + for pgp credential type. + + Examples: + Creating a Username + Password credential + + .. code-block:: python + + gmp.create_credential( + name='UP Credential', + credential_type=CredentialType.USERNAME_PASSWORD, + login='foo', + password='bar', + ) + + Creating a Username + SSH Key credential + + .. code-block:: python + + with open('path/to/private-ssh-key') as f: + key = f.read() + + gmp.create_credential( + name='USK Credential', + credential_type=CredentialType.USERNAME_SSH_KEY, + login='foo', + key_phrase='foobar', + private_key=key, + ) + + Creating a PGP credential + + .. note:: + + A compatible public pgp key file can be exported with GnuPG via + :: + + $ gpg --armor --export alice@cyb.org > alice.asc + + .. code-block:: python + + with open('path/to/pgp.key.asc') as f: + key = f.read() + + gmp.create_credential( + name='PGP Credential', + credential_type=CredentialType.PGP_ENCRYPTION_KEY, + public_key=key, + ) + + Creating a S/MIME credential + + .. code-block:: python + + with open('path/to/smime-cert') as f: + cert = f.read() + + gmp.create_credential( + name='SMIME Credential', + credential_type=CredentialType.SMIME_CERTIFICATE, + certificate=cert, + ) + + Creating a Password-Only credential + + .. code-block:: python + + gmp.create_credential( + name='Password-Only Credential', + credential_type=CredentialType.PASSWORD_ONLY, + password='foo', + ) + """ + return self._send_and_transform_command( + Credentials.create_credential( + name, + credential_type, + comment=comment, + allow_insecure=allow_insecure, + certificate=certificate, + key_phrase=key_phrase, + private_key=private_key, + login=login, + password=password, + auth_algorithm=auth_algorithm, + community=community, + privacy_algorithm=privacy_algorithm, + privacy_password=privacy_password, + public_key=public_key, + ) + ) + + def delete_credential( + self, credential_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Delete an existing credential + + Args: + credential_id: UUID of the credential to delete + ultimate: Whether to remove entirely or to the trashcan. + """ + return self._send_and_transform_command( + Credentials.delete_credential(credential_id, ultimate=ultimate) + ) + + def get_credentials( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + scanners: Optional[bool] = None, + trash: Optional[bool] = None, + targets: Optional[bool] = None, + ) -> T: + """Request a list of credentials + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + scanners: Whether to include a list of scanners using the + credentials + trash: Whether to get the trashcan credentials instead + targets: Whether to include a list of targets using the credentials + """ + return self._send_and_transform_command( + Credentials.get_credentials( + filter_string=filter_string, + filter_id=filter_id, + scanners=scanners, + trash=trash, + targets=targets, + ) + ) + + def get_credential( + self, + credential_id: str, + *, + scanners: Optional[bool] = None, + targets: Optional[bool] = None, + credential_format: Optional[Union[CredentialFormat, str]] = None, + ) -> T: + """Request a single credential + + Args: + credential_id: UUID of an existing credential + scanners: Whether to include a list of scanners using the + credentials + targets: Whether to include a list of targets using the credentials + credential_format: One of "key", "rpm", "deb", "exe" or "pem" + """ + return self._send_and_transform_command( + Credentials.get_credential( + credential_id, + scanners=scanners, + targets=targets, + credential_format=credential_format, + ) + ) + + def modify_credential( + self, + credential_id: str, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + allow_insecure: Optional[bool] = None, + certificate: Optional[str] = None, + key_phrase: Optional[str] = None, + private_key: Optional[str] = None, + login: Optional[str] = None, + password: Optional[str] = None, + auth_algorithm: Optional[Union[SnmpAuthAlgorithm, str]] = None, + community: Optional[str] = None, + privacy_algorithm: Optional[Union[SnmpPrivacyAlgorithm, str]] = None, + privacy_password: Optional[str] = None, + public_key: Optional[str] = None, + ) -> T: + """Modifies an existing credential. + + Args: + credential_id: UUID of the credential + name: Name of the credential + comment: Comment for the credential + allow_insecure: Whether to allow insecure use of the credential + certificate: Certificate for the credential + key_phrase: Key passphrase for the private key + private_key: Private key to use for login + login: Username for the credential + password: Password for the credential + auth_algorithm: The authentication algorithm for SNMP + community: The SNMP community + privacy_algorithm: The privacy algorithm for SNMP + privacy_password: The SNMP privacy password + public_key: PGP public key in *armor* plain text format + """ + return self._send_and_transform_command( + Credentials.modify_credential( + credential_id, + name=name, + comment=comment, + allow_insecure=allow_insecure, + certificate=certificate, + key_phrase=key_phrase, + private_key=private_key, + login=login, + password=password, + auth_algorithm=auth_algorithm, + community=community, + privacy_algorithm=privacy_algorithm, + privacy_password=privacy_password, + public_key=public_key, + ) + ) + + def clone_filter(self, filter_id: EntityID) -> T: + """Clone a filter + + Args: + filter_id: ID of the filter to clone + """ + return self._send_and_transform_command(Filters.clone_filter(filter_id)) + + def create_filter( + self, + name: str, + *, + filter_type: Optional[FilterType] = None, + comment: Optional[str] = None, + term: Optional[str] = None, + ) -> T: + """Create a new filter + + Args: + name: Name of the new filter + filter_type: Filter for entity type + comment: Comment for the filter + term: Filter term e.g. 'name=foo' + """ + return self._send_and_transform_command( + Filters.create_filter( + name, filter_type=filter_type, comment=comment, term=term + ) + ) + + def delete_filter( + self, filter_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing filter + + Args: + filter_id: UUID of the filter to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Filters.delete_filter(filter_id, ultimate=ultimate) + ) + + def get_filters( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + alerts: Optional[bool] = None, + ) -> T: + """Request a list of filters + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan filters instead + alerts: Whether to include list of alerts that use the filter. + """ + return self._send_and_transform_command( + Filters.get_filters( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + alerts=alerts, + ) + ) + + def get_filter( + self, filter_id: EntityID, *, alerts: Optional[bool] = None + ) -> T: + """Request a single filter + + Args: + filter_id: UUID of an existing filter + alerts: Whether to include list of alerts that use the filter. + """ + return self._send_and_transform_command( + Filters.get_filter(filter_id, alerts=alerts) + ) + + def modify_filter( + self, + filter_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + term: Optional[str] = None, + filter_type: Optional[FilterType] = None, + ) -> T: + """Modifies an existing filter. + + Args: + filter_id: UUID of the filter to be modified + comment: Comment on filter. + name: Name of filter. + term: Filter term. + filter_type: Resource type filter applies to. + """ + return self._send_and_transform_command( + Filters.modify_filter( + filter_id, + comment=comment, + name=name, + term=term, + filter_type=filter_type, + ) + ) + + def clone_group(self, group_id: EntityID) -> T: + """Clone an existing group + + Args: + group_id: UUID of an existing group to clone from + """ + return self._send_and_transform_command(Groups.clone_group(group_id)) + + def create_group( + self, + name: str, + *, + comment: Optional[str] = None, + special: Optional[bool] = False, + users: Optional[list[str]] = None, + ) -> T: + """Create a new group + + Args: + name: Name of the new group + comment: Comment for the group + special: Create permission giving members full access to each + other's entities + users: List of user names to be in the group + """ + return self._send_and_transform_command( + Groups.create_group( + name, comment=comment, special=special, users=users + ) + ) + + def delete_group( + self, group_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing group + + Args: + group_id: UUID of the group to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Groups.delete_group(group_id, ultimate=ultimate) + ) + + def get_groups( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + ) -> T: + """Request a list of groups + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan groups instead + """ + return self._send_and_transform_command( + Groups.get_groups( + filter_string=filter_string, filter_id=filter_id, trash=trash + ) + ) + + def get_group(self, group_id: EntityID) -> T: + """Request a single group + + Args: + group_id: UUID of an existing group + """ + return self._send_and_transform_command(Groups.get_group(group_id)) + + def modify_group( + self, + group_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + users: Optional[list[str]] = None, + ) -> T: + """Modifies an existing group. + + Args: + group_id: UUID of group to modify. + comment: Comment on group. + name: Name of group. + users: List of user names to be in the group + """ + return self._send_and_transform_command( + Groups.modify_group( + group_id, comment=comment, name=name, users=users + ) + ) + + def create_host(self, name: str, *, comment: Optional[str] = None) -> T: + """Create a new host host + + Args: + name: Name for the new host host + comment: Comment for the new host host + """ + return self._send_and_transform_command( + Hosts.create_host(name, comment=comment) + ) + + def delete_host(self, host_id: EntityID) -> T: + """Deletes an existing host + + Args: + host_id: UUID of the single host to delete. + """ + return self._send_and_transform_command(Hosts.delete_host(host_id)) + + def get_hosts( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of hosts + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Whether to include additional information (e.g. tags) + """ + return self._send_and_transform_command( + Hosts.get_hosts( + filter_string=filter_string, + filter_id=filter_id, + details=details, + ) + ) + + def get_host( + self, host_id: EntityID, *, details: Optional[bool] = None + ) -> T: + """Request a single host + + Arguments: + host_id: UUID of an existing host + details: Whether to include additional information (e.g. tags) + """ + return self._send_and_transform_command( + Hosts.get_host(host_id, details=details) + ) + + def modify_host( + self, host_id: EntityID, *, comment: Optional[str] = None + ) -> T: + """Modifies an existing host. + + Args: + host_id: UUID of the host to be modified. + comment: Comment for the host. Not passing a comment + arguments clears the comment for this host. + """ + return self._send_and_transform_command( + Hosts.modify_host(host_id, comment=comment) + ) + + def delete_operating_system( + self, + operating_system_id: EntityID, + ) -> T: + """Deletes an existing operating system + + Args: + operating_system_id: UUID of the single operating_system to delete. + """ + return self._send_and_transform_command( + OperatingSystems.delete_operating_system(operating_system_id) + ) + + def get_operating_systems( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of operating systems + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Whether to include additional information (e.g. tags) + """ + return self._send_and_transform_command( + OperatingSystems.get_operating_systems( + filter_string=filter_string, + filter_id=filter_id, + details=details, + ) + ) + + def get_operating_system( + self, operating_system_id: EntityID, *, details: Optional[bool] = None + ) -> T: + """Request a single operating system + + Args: + operating_system_id: UUID of an existing operating_system + details: Whether to include additional information (e.g. tags) + """ + return self._send_and_transform_command( + OperatingSystems.get_operating_system( + operating_system_id, details=details + ) + ) + + def modify_operating_system( + self, operating_system_id: EntityID, *, comment: Optional[str] = None + ) -> T: + """Modifies an existing operating system. + + Args: + operating_system_id: UUID of the operating_system to be modified. + comment: Comment for the operating_system. Not passing a comment + arguments clears the comment for this operating system. + """ + return self._send_and_transform_command( + OperatingSystems.modify_operating_system( + operating_system_id, comment=comment + ) + ) + + def clone_permission(self, permission_id: EntityID) -> T: + """Clone an existing permission + + Args: + permission_id: UUID of an existing permission to clone from + """ + return self._send_and_transform_command( + Permissions.clone_permission(permission_id) + ) + + def create_permission( + self, + name: str, + subject_id: EntityID, + subject_type: Union[PermissionSubjectType, str], + *, + resource_id: Optional[str] = None, + resource_type: Optional[Union[EntityType, str]] = None, + comment: Optional[str] = None, + ) -> T: + """Create a new permission + + Args: + name: Name of the new permission + subject_id: UUID of subject to whom the permission is granted + subject_type: Type of the subject user, group or role + comment: Comment for the permission + resource_id: UUID of entity to which the permission applies + resource_type: Type of the resource. For Super permissions user, + group or role + """ + return self._send_and_transform_command( + Permissions.create_permission( + name, + subject_id, + subject_type, + resource_id=resource_id, + resource_type=resource_type, + comment=comment, + ) + ) + + def delete_permission( + self, permission_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing permission + + Args: + permission_id: UUID of the permission to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Permissions.delete_permission(permission_id, ultimate=ultimate) + ) + + def get_permissions( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + trash: Optional[bool] = None, + ) -> T: + """Request a list of permissions + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get permissions in the trashcan instead + """ + return self._send_and_transform_command( + Permissions.get_permissions( + filter_string=filter_string, filter_id=filter_id, trash=trash + ) + ) + + def get_permission(self, permission_id: EntityID) -> T: + """Request a single permission + + Args: + permission_id: UUID of an existing permission + """ + return self._send_and_transform_command( + Permissions.get_permission(permission_id) + ) + + def modify_permission( + self, + permission_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + resource_id: Optional[EntityID] = None, + resource_type: Optional[Union[EntityType, str]] = None, + subject_id: Optional[EntityID] = None, + subject_type: Optional[Union[PermissionSubjectType, str]] = None, + ) -> T: + """Modifies an existing permission. + + Args: + permission_id: UUID of permission to be modified. + comment: The comment on the permission. + name: Permission name, currently the name of a command. + subject_id: UUID of subject to whom the permission is granted + subject_type: Type of the subject user, group or role + resource_id: UUID of entity to which the permission applies + resource_type: Type of the resource. For Super permissions user, + group or role + """ + return self._send_and_transform_command( + Permissions.modify_permission( + permission_id, + comment=comment, + name=name, + resource_id=resource_id, + resource_type=resource_type, + subject_id=subject_id, + subject_type=subject_type, + ) + ) + + def clone_policy(self, policy_id: EntityID) -> T: + """Clone a policy from an existing one + + Args: + policy_id: UUID of the existing policy + """ + return self._send_and_transform_command( + Policies.clone_policy(policy_id) + ) + + def create_policy( + self, + name: str, + *, + policy_id: Optional[EntityID] = None, + comment: Optional[str] = None, + ) -> T: + """Create a new policy + + Args: + name: Name of the new policy + policy_id: UUID of an existing policy as base. By default the empty + policy is used. + comment: A comment on the policy + """ + return self._send_and_transform_command( + Policies.create_policy(name, policy_id=policy_id, comment=comment) + ) + + def delete_policy( + self, policy_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing policy + + Args: + policy_id: UUID of the policy to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Policies.delete_policy(policy_id, ultimate=ultimate) + ) + + def get_policies( + self, + *, + audits: Optional[bool] = None, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + families: Optional[bool] = None, + preferences: Optional[bool] = None, + trash: Optional[bool] = None, + ) -> T: + """Request a list of policies + + Args: + audits: Whether to get audits using the policy + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Whether to get families, preferences, nvt selectors + and tasks. + families: Whether to include the families if no details are + requested + preferences: Whether to include the preferences if no details are + requested + trash: Whether to get the trashcan audits instead + """ + return self._send_and_transform_command( + Policies.get_policies( + audits=audits, + filter_string=filter_string, + filter_id=filter_id, + details=details, + families=families, + preferences=preferences, + trash=trash, + ) + ) + + def get_policy( + self, policy_id: EntityID, *, audits: Optional[bool] = None + ) -> T: + """Request a single policy + + Args: + policy_id: UUID of an existing policy + audits: Whether to get audits using this policy + """ + return self._send_and_transform_command( + Policies.get_policy(policy_id, audits=audits) + ) + + def import_policy(self, policy: str) -> T: + """Import a policy from XML + + Args: + policy: Policy XML as string to import. This XML must + contain a :code:`` root element. + """ + return self._send_and_transform_command(Policies.import_policy(policy)) + + def modify_policy_set_nvt_preference( + self, + policy_id: EntityID, + name: str, + nvt_oid: str, + *, + value: Optional[str] = None, + ) -> T: + """Modifies the nvt preferences of an existing policy. + + Args: + policy_id: UUID of policy to modify. + name: Name for preference to change. + nvt_oid: OID of the NVT associated with preference to modify + value: New value for the preference. None to delete the preference + and to use the default instead. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_nvt_preference( + policy_id, name, nvt_oid, value=value + ) + ) + + def modify_policy_set_name(self, policy_id: EntityID, name: str) -> T: + """Modifies the name of an existing policy + + Args: + policy_id: UUID of policy to modify. + name: New name for the policy. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_name(policy_id, name) + ) + + def modify_policy_set_comment( + self, policy_id: EntityID, comment: Optional[str] = None + ) -> T: + """Modifies the comment of an existing policy + + Args: + policy_id: UUID of policy to modify. + comment: Comment to set on a policy. Default is an + empty comment and the previous comment will be + removed. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_comment(policy_id, comment=comment) + ) + + def modify_policy_set_scanner_preference( + self, policy_id: EntityID, name: str, *, value: Optional[str] = None + ) -> T: + """Modifies the scanner preferences of an existing policy + + Args: + policy_id: UUID of policy to modify. + name: Name of the scanner preference to change + value: New value for the preference. None to delete the preference + and to use the default instead. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_scanner_preference( + policy_id, name, value=value + ) + ) + + def modify_policy_set_nvt_selection( + self, policy_id: EntityID, family: str, nvt_oids: Sequence[str] + ) -> T: + """Modifies the selected nvts of an existing policy + + The manager updates the given family in the policy to include only the + given NVTs. + + Args: + policy_id: UUID of policy to modify. + family: Name of the NVT family to include NVTs from + nvt_oids: List of NVTs to select for the family. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_nvt_selection( + policy_id, family, nvt_oids + ) + ) + + def modify_policy_set_family_selection( + self, + policy_id: EntityID, + families: Sequence[tuple[str, bool, bool]], + *, + auto_add_new_families: Optional[bool] = True, + ) -> T: + """ + Selected the NVTs of a policy at a family level. + + Args: + policy_id: UUID of policy to modify. + families: A list of tuples with the first entry being the name + of the NVT family selected, second entry a boolean indicating + whether new NVTs should be added to the family automatically, + and third entry a boolean indicating whether all nvts from + the family should be included. + auto_add_new_families: Whether new families should be added to the + policy automatically. Default: True. + """ + return self._send_and_transform_command( + Policies.modify_policy_set_family_selection( + policy_id, families, auto_add_new_families=auto_add_new_families + ) + ) + + def delete_report(self, report_id: EntityID) -> T: + """Deletes an existing report + + Args: + report_id: UUID of the report to be deleted. + """ + return self._send_and_transform_command( + Reports.delete_report(report_id) + ) + + def get_report( + self, + report_id: EntityID, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + delta_report_id: Optional[EntityID] = None, + report_format_id: Optional[Union[str, ReportFormatType]] = None, + ignore_pagination: Optional[bool] = None, + details: Optional[bool] = True, + ) -> T: + """Request a single report + + Args: + report_id: UUID of an existing report + filter_string: Filter term to use to filter results in the report + filter_id: UUID of filter to use to filter results in the report + delta_report_id: UUID of an existing report to compare report to. + report_format_id: UUID of report format to use + or ReportFormatType (enum) + ignore_pagination: Whether to ignore the filter terms "first" and + "rows". + details: Request additional report information details + defaults to True + """ + return self._send_and_transform_command( + Reports.get_report( + report_id, + filter_string=filter_string, + filter_id=filter_id, + delta_report_id=delta_report_id, + report_format_id=report_format_id, + ignore_pagination=ignore_pagination, + details=details, + ) + ) + + def get_reports( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + note_details: Optional[bool] = None, + override_details: Optional[bool] = None, + ignore_pagination: Optional[bool] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of reports + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + note_details: If notes are included, whether to include note details + override_details: If overrides are included, whether to include + override details + ignore_pagination: Whether to ignore the filter terms "first" and + "rows". + details: Whether to exclude results + """ + return self._send_and_transform_command( + Reports.get_reports( + filter_string=filter_string, + filter_id=filter_id, + note_details=note_details, + override_details=override_details, + ignore_pagination=ignore_pagination, + details=details, + ) + ) + + def import_report( + self, + report: str, + task_id: EntityID, + *, + in_assets: Optional[bool] = None, + ) -> T: + """Import a Report from XML + + Args: + report: Report XML as string to import. This XML must contain + a :code:`` root element. + task_id: UUID of task to import report to + in_asset: Whether to create or update assets using the report + """ + return self._send_and_transform_command( + Reports.import_report(report, task_id, in_assets=in_assets) + ) + + def get_result(self, result_id: EntityID) -> T: + """Request a single result + + Args: + result_id: UUID of an existing result + """ + return self._send_and_transform_command(Results.get_result(result_id)) + + def get_results( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + task_id: Optional[str] = None, + note_details: Optional[bool] = None, + override_details: Optional[bool] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of results + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + task_id: UUID of task for note and override handling + note_details: If notes are included, whether to include note details + override_details: If overrides are included, whether to include + override details + details: Whether to include additional details of the results + """ + return self._send_and_transform_command( + Results.get_results( + filter_string=filter_string, + filter_id=filter_id, + task_id=task_id, + note_details=note_details, + override_details=override_details, + details=details, + ) + ) + + def clone_role(self, role_id: EntityID) -> T: + """Clone an existing role + + Args: + role_id: UUID of an existing role to clone from + """ + return self._send_and_transform_command(Roles.clone_role(role_id)) + + def create_role( + self, + name: str, + *, + comment: Optional[str] = None, + users: Optional[list[str]] = None, + ) -> T: + """Create a new role + + Args: + name: Name of the role + comment: Comment for the role + users: List of user names to add to the role + """ + return self._send_and_transform_command( + Roles.create_role(name, comment=comment, users=users) + ) + + def delete_role( + self, role_id: str, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing role + + Args: + role_id: UUID of the role to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Roles.delete_role(role_id, ultimate=ultimate) + ) + + def get_roles( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + ) -> T: + """Request a list of roles + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan roles instead + """ + return self._send_and_transform_command( + Roles.get_roles( + filter_string=filter_string, filter_id=filter_id, trash=trash + ) + ) + + def get_role(self, role_id: EntityID) -> T: + """Request a single role + + Args: + role_id: UUID of an existing role + """ + return self._send_and_transform_command(Roles.get_role(role_id)) + + def modify_role( + self, + role_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + users: Optional[list[str]] = None, + ) -> T: + """Modifies an existing role. + + Args: + role_id: UUID of role to modify. + comment: Name of role. + name: Comment on role. + users: List of user names. + """ + return self._send_and_transform_command( + Roles.modify_role(role_id, comment=comment, name=name, users=users) + ) + + def clone_schedule(self, schedule_id: EntityID) -> T: + """Clone an existing schedule + + Args: + schedule_id: UUID of an existing schedule to clone from + """ + return self._send_and_transform_command( + Schedules.clone_schedule(schedule_id) + ) + + def create_schedule( + self, + name: str, + icalendar: str, + timezone: str, + *, + comment: Optional[str] = None, + ) -> T: + """Create a new schedule based in `iCalendar`_ data. + + Example: + Requires https://pypi.org/project/icalendar/ + + .. code-block:: python + + import pytz + + from datetime import datetime + + from icalendar import Calendar, Event + + cal = Calendar() + + cal.add('prodid', '-//Foo Bar//') + cal.add('version', '2.0') + + event = Event() + event.add('dtstamp', datetime.now(tz=pytz.UTC)) + event.add('dtstart', datetime(2020, 1, 1, tzinfo=pytz.utc)) + + cal.add_component(event) + + gmp.create_schedule( + name="My Schedule", + icalendar=cal.to_ical(), + timezone='UTC' + ) + + Args: + name: Name of the new schedule + icalendar: `iCalendar`_ (RFC 5545) based data. + timezone: Timezone to use for the icalendar events e.g + Europe/Berlin. If the datetime values in the icalendar data are + missing timezone information this timezone gets applied. + Otherwise the datetime values from the icalendar data are + displayed in this timezone + comment: Comment on schedule. + + .. _iCalendar: + https://tools.ietf.org/html/rfc5545 + """ + return self._send_and_transform_command( + Schedules.create_schedule( + name, icalendar, timezone, comment=comment + ) + ) + + def delete_schedule( + self, schedule_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing schedule + + Args: + schedule_id: UUID of the schedule to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Schedules.delete_schedule(schedule_id, ultimate=ultimate) + ) + + def get_schedules( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> T: + """Request a list of schedules + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan schedules instead + tasks: Whether to include tasks using the schedules + """ + return self._send_and_transform_command( + Schedules.get_schedules( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + tasks=tasks, + ) + ) + + def get_schedule( + self, schedule_id: EntityID, *, tasks: Optional[bool] = None + ) -> T: + """Request a single schedule + + Args: + schedule_id: UUID of an existing schedule + tasks: Whether to include tasks using the schedules + """ + return self._send_and_transform_command( + Schedules.get_schedule(schedule_id, tasks=tasks) + ) + + def modify_schedule( + self, + schedule_id: EntityID, + *, + name: Optional[str] = None, + icalendar: Optional[str] = None, + timezone: Optional[str] = None, + comment: Optional[str] = None, + ) -> T: + """Modifies an existing schedule + + Args: + schedule_id: UUID of the schedule to be modified + name: Name of the schedule + icalendar: `iCalendar`_ (RFC 5545) based data. + timezone: Timezone to use for the icalendar events e.g + Europe/Berlin. If the datetime values in the icalendar data are + missing timezone information this timezone gets applied. + Otherwise the datetime values from the icalendar data are + displayed in this timezone + comment: Comment on schedule. + + .. _iCalendar: + https://tools.ietf.org/html/rfc5545 + """ + return self._send_and_transform_command( + Schedules.modify_schedule( + schedule_id, + name=name, + icalendar=icalendar, + timezone=timezone, + comment=comment, + ) + ) + + def get_nvt_families(self, *, sort_order: Optional[str] = None) -> T: + """Request a list of nvt families + + Args: + sort_order: Sort order + """ + return self._send_and_transform_command( + Nvts.get_nvt_families(sort_order=sort_order) + ) + + def get_scan_config_nvts( + self, + *, + details: Optional[bool] = None, + preferences: Optional[bool] = None, + preference_count: Optional[bool] = None, + timeout: Optional[bool] = None, + config_id: Optional[EntityID] = None, + preferences_config_id: Optional[EntityID] = None, + family: Optional[str] = None, + sort_order: Optional[str] = None, + sort_field: Optional[str] = None, + ) -> T: + """Request a list of nvts + + Args: + details: Whether to include full details + preferences: Whether to include nvt preferences + preference_count: Whether to include preference count + timeout: Whether to include the special timeout preference + config_id: UUID of scan config to which to limit the NVT listing + preferences_config_id: UUID of scan config to use for preference + values + family: Family to which to limit NVT listing + sort_order: Sort order + sort_field: Sort field + """ + return self._send_and_transform_command( + Nvts.get_scan_config_nvts( + details=details, + preferences=preferences, + preference_count=preference_count, + timeout=timeout, + config_id=config_id, + preferences_config_id=preferences_config_id, + family=family, + sort_order=sort_order, + sort_field=sort_field, + ) + ) + + def get_scan_config_nvt(self, nvt_oid: str) -> T: + """Request a single nvt + + Args: + nvt_oid: OID of an existing nvt + """ + return self._send_and_transform_command( + Nvts.get_scan_config_nvt(nvt_oid) + ) + + def get_nvts( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + extended: Optional[bool] = None, + preferences: Optional[bool] = None, + preference_count: Optional[bool] = None, + timeout: Optional[bool] = None, + config_id: Optional[str] = None, + preferences_config_id: Optional[str] = None, + family: Optional[str] = None, + sort_order: Optional[str] = None, + sort_field: Optional[str] = None, + ) -> T: + """Request a list of NVTs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + extended: Whether to receive extended NVT information + (calls get_nvts, instead of get_info) + preferences: Whether to include NVT preferences (only for extended) + preference_count: Whether to include preference count (only for extended) + timeout: Whether to include the special timeout preference (only for extended) + config_id: UUID of scan config to which to limit the NVT listing (only for extended) + preferences_config_id: UUID of scan config to use for preference + values (only for extended) + family: Family to which to limit NVT listing (only for extended) + sort_order: Sort order (only for extended) + sort_field: Sort field (only for extended) + """ + return self._send_and_transform_command( + Nvts.get_nvts( + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + extended=extended, + preferences=preferences, + preference_count=preference_count, + timeout=timeout, + config_id=config_id, + preferences_config_id=preferences_config_id, + family=family, + sort_order=sort_order, + sort_field=sort_field, + ) + ) + + def get_nvt(self, nvt_id: str, *, extended: Optional[bool] = None) -> T: + """Request a single NVT + + Args: + nvt_id: ID of an existing NVT + extended: Whether to receive extended NVT information + (calls get_nvts, instead of get_info) + """ + return self._send_and_transform_command( + Nvts.get_nvt(nvt_id, extended=extended) + ) + + def get_nvt_preferences( + self, + *, + nvt_oid: Optional[str] = None, + ) -> T: + """Request a list of preferences + + The preference element includes just the + name and value, with the NVT and type built into the name. + + Args: + nvt_oid: OID of nvt + """ + return self._send_and_transform_command( + Nvts.get_nvt_preferences(nvt_oid=nvt_oid) + ) + + def get_nvt_preference( + self, + name: str, + *, + nvt_oid: Optional[str] = None, + ) -> T: + """Request a nvt preference + + Args: + name: name of a particular preference + nvt_oid: OID of nvt + config_id: UUID of scan config of which to show preference values + """ + return self._send_and_transform_command( + Nvts.get_nvt_preference(name, nvt_oid=nvt_oid) + ) + + def get_info(self, info_id: EntityID, info_type: InfoType) -> T: + """Request a single secinfo + + Arguments: + info_id: ID of an existing secinfo + info_type: Type must be either CERT_BUND_ADV, CPE, CVE, + DFN_CERT_ADV, OVALDEF, NVT + """ + return self._send_and_transform_command( + SecInfo.get_info(info_id, info_type) + ) + + def get_info_list( + self, + info_type: InfoType, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of security information + + Args: + info_type: Type must be either CERT_BUND_ADV, CPE, CVE, + DFN_CERT_ADV, OVALDEF or NVT + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + return self._send_and_transform_command( + SecInfo.get_info_list( + info_type, + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + ) + ) + + def get_cves( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of CVEs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + return self._send_and_transform_command( + Cves.get_cves( + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + ) + ) + + def get_cve(self, cve_id: str) -> T: + """Request a single CVE + + Args: + cve_id: ID of an existing CVE + """ + return self._send_and_transform_command(Cves.get_cve(cve_id)) + + def get_cpes( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of CPEs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + return self._send_and_transform_command( + Cpes.get_cpes( + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + ) + ) + + def get_cpe(self, cpe_id: str) -> T: + """Request a single CPE + + Args: + cpe_id: ID of an existing CPE + """ + return self._send_and_transform_command(Cpes.get_cpe(cpe_id)) + + def get_dfn_cert_advisories( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of DFN-CERT Advisories + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + return self._send_and_transform_command( + DfnCertAdvisories.get_dfn_cert_advisories( + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + ) + ) + + def get_dfn_cert_advisory(self, cert_id: EntityID) -> T: + """Request a single DFN-CERT Advisory + + Args: + cert_id: ID of an existing DFN-CERT Advisory + """ + return self._send_and_transform_command( + DfnCertAdvisories.get_dfn_cert_advisory(cert_id) + ) + + def get_cert_bund_advisories( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of CERT-BUND Advisories + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + return self._send_and_transform_command( + CertBundAdvisories.get_cert_bund_advisories( + filter_string=filter_string, + filter_id=filter_id, + name=name, + details=details, + ) + ) + + def get_cert_bund_advisory(self, cert_id: EntityID) -> T: + """Request a single CERT-BUND Advisory + + Args: + cert_id: ID of an existing CERT-BUND Advisory + """ + return self._send_and_transform_command( + CertBundAdvisories.get_cert_bund_advisory(cert_id) + ) + + def clone_tag(self, tag_id: EntityID) -> T: + """Clone an existing tag + + Args: + tag_id: UUID of an existing tag to clone from + """ + return self._send_and_transform_command(Tags.clone_tag(tag_id)) + + def create_tag( + self, + name: str, + resource_type: EntityType, + *, + resource_filter: Optional[str] = None, + resource_ids: Optional[list[EntityID]] = None, + value: Optional[str] = None, + comment: Optional[str] = None, + active: Optional[bool] = None, + ) -> T: + """Create a tag + + Args: + name: Name of the tag. A full tag name consisting of namespace and + predicate e.g. `foo:bar`. + resource_type: Entity type the tag is to be attached to. + resource_filter: Filter term to select resources the tag is to be + attached to. Only one of resource_filter or resource_ids can be + provided. + resource_ids: IDs of the resources the tag is to be attached to. + Only one of resource_filter or resource_ids can be provided. + value: Value associated with the tag. + comment: Comment for the tag. + active: Whether the tag should be active. + """ + return self._send_and_transform_command( + Tags.create_tag( + name, + resource_type, + resource_filter=resource_filter, + resource_ids=resource_ids, + value=value, + comment=comment, + active=active, + ) + ) + + def delete_tag( + self, tag_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing tag + + Args: + tag_id: UUID of the tag to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Tags.delete_tag(tag_id, ultimate=ultimate) + ) + + def get_tags( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + names_only: Optional[bool] = None, + ) -> T: + """Request a list of tags + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get tags from the trashcan instead + names_only: Whether to get only distinct tag names + """ + return self._send_and_transform_command( + Tags.get_tags( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + names_only=names_only, + ) + ) + + def get_tag(self, tag_id: EntityID) -> T: + """Request a single tag + + Args: + tag_id: UUID of an existing tag + """ + return self._send_and_transform_command(Tags.get_tag(tag_id)) + + def modify_tag( + self, + tag_id: EntityID, + *, + comment: Optional[str] = None, + name: Optional[str] = None, + value: Optional[str] = None, + active: Optional[bool] = None, + resource_action: Optional[str] = None, + resource_type: Optional[EntityType] = None, + resource_filter: Optional[str] = None, + resource_ids: Optional[list[EntityID]] = None, + ) -> T: + """Modifies an existing tag. + + Args: + tag_id: UUID of the tag. + comment: Comment to add to the tag. + name: Name of the tag. + value: Value of the tag. + active: Whether the tag is active. + resource_action: Whether to add or remove resources instead of + overwriting. One of '', 'add', 'set' or 'remove'. + resource_type: Type of the resources to which to attach the tag. + Required if resource_filter is set. + resource_filter: Filter term to select resources the tag is to be + attached to. + resource_ids: IDs of the resources to which to attach the tag. + """ + return self._send_and_transform_command( + Tags.modify_tag( + tag_id, + comment=comment, + name=name, + value=value, + active=active, + resource_action=resource_action, + resource_type=resource_type, + resource_filter=resource_filter, + resource_ids=resource_ids, + ) + ) + + def clone_task(self, task_id: EntityID) -> T: + """Clone an existing task + + Args: + task_id: UUID of existing task to clone from + """ + return self._send_and_transform_command(Tasks.clone_task(task_id)) + + def create_container_task( + self, name: str, *, comment: Optional[str] = None + ) -> T: + """Create a new container task + + A container task is a "meta" task to import and view reports from other + systems. + + Args: + name: Name of the task + comment: Comment for the task + """ + return self._send_and_transform_command( + Tasks.create_container_task(name, comment=comment) + ) + + def create_task( + self, + name: str, + config_id: EntityID, + target_id: EntityID, + scanner_id: EntityID, + *, + alterable: Optional[bool] = None, + hosts_ordering: Optional[HostsOrdering] = None, + schedule_id: Optional[EntityID] = None, + alert_ids: Optional[Sequence[EntityID]] = None, + comment: Optional[str] = None, + schedule_periods: Optional[int] = None, + observers: Optional[Sequence[str]] = None, + preferences: Optional[Mapping[str, SupportsStr]] = None, + ) -> T: + """Create a new scan task + + Args: + name: Name of the new task + config_id: UUID of config to use by the task + target_id: UUID of target to be scanned + scanner_id: UUID of scanner to use for scanning the target + comment: Comment for the task + alterable: Whether the task should be alterable + alert_ids: List of UUIDs for alerts to be applied to the task + hosts_ordering: The order hosts are scanned in + schedule_id: UUID of a schedule when the task should be run. + schedule_periods: A limit to the number of times the task will be + scheduled, or 0 for no limit + observers: List of names or ids of users which should be allowed to + observe this task + preferences: Name/Value pairs of scanner preferences. + """ + return self._send_and_transform_command( + Tasks.create_task( + name, + config_id, + target_id, + scanner_id, + alterable=alterable, + hosts_ordering=hosts_ordering, + schedule_id=schedule_id, + alert_ids=alert_ids, + comment=comment, + schedule_periods=schedule_periods, + observers=observers, + preferences=preferences, + ) + ) + + def delete_task( + self, task_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing task + + Args: + task_id: UUID of the task to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Tasks.delete_task(task_id, ultimate=ultimate) + ) + + def get_tasks( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + details: Optional[bool] = None, + schedules_only: Optional[bool] = None, + ) -> T: + """Request a list of tasks + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan tasks instead + details: Whether to include full task details + schedules_only: Whether to only include id, name and schedule + details + """ + return self._send_and_transform_command( + Tasks.get_tasks( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + details=details, + schedules_only=schedules_only, + ) + ) + + def get_task(self, task_id: EntityID) -> T: + """Request a single task + + Args: + task_id: UUID of an existing task + """ + return self._send_and_transform_command(Tasks.get_task(task_id)) + + def modify_task( + self, + task_id: EntityID, + *, + name: Optional[str] = None, + config_id: Optional[EntityID] = None, + target_id: Optional[EntityID] = None, + scanner_id: Optional[EntityID] = None, + alterable: Optional[bool] = None, + hosts_ordering: Optional[HostsOrdering] = None, + schedule_id: Optional[EntityID] = None, + schedule_periods: Optional[int] = None, + comment: Optional[str] = None, + alert_ids: Optional[Sequence[EntityID]] = None, + observers: Optional[Sequence[str]] = None, + preferences: Optional[Mapping[str, SupportsStr]] = None, + ) -> T: + """Modifies an existing task. + + Args: + task_id: UUID of task to modify. + name: The name of the task. + config_id: UUID of scan config to use by the task + target_id: UUID of target to be scanned + scanner_id: UUID of scanner to use for scanning the target + comment: The comment on the task. + alert_ids: List of UUIDs for alerts to be applied to the task + hosts_ordering: The order hosts are scanned in + schedule_id: UUID of a schedule when the task should be run. + schedule_periods: A limit to the number of times the task will be + scheduled, or 0 for no limit. + observers: List of names or ids of users which should be allowed to + observe this task + preferences: Name/Value pairs of scanner preferences. + """ + return self._send_and_transform_command( + Tasks.modify_task( + task_id, + name=name, + config_id=config_id, + target_id=target_id, + scanner_id=scanner_id, + alterable=alterable, + hosts_ordering=hosts_ordering, + schedule_id=schedule_id, + schedule_periods=schedule_periods, + comment=comment, + alert_ids=alert_ids, + observers=observers, + preferences=preferences, + ) + ) + + def move_task( + self, task_id: EntityID, *, slave_id: Optional[EntityID] = None + ) -> T: + """Move an existing task to another GMP slave scanner or the master + + Args: + task_id: UUID of the task to be moved + slave_id: UUID of the sensor to reassign the task to, empty for master. + """ + return self._send_and_transform_command( + Tasks.move_task(task_id, slave_id=slave_id) + ) + + def start_task(self, task_id: EntityID) -> T: + """Start an existing task + + Args: + task_id: UUID of the task to be started + """ + return self._send_and_transform_command(Tasks.start_task(task_id)) + + def resume_task(self, task_id: EntityID) -> T: + """Resume an existing stopped task + + Args: + task_id: UUID of the task to be resumed + """ + return self._send_and_transform_command(Tasks.resume_task(task_id)) + + def stop_task(self, task_id: EntityID) -> T: + """Stop an existing running task + + Args: + task_id: UUID of the task to be stopped + """ + return self._send_and_transform_command(Tasks.stop_task(task_id)) + + def clone_ticket(self, ticket_id: EntityID) -> T: + """Clone an existing ticket + + Args: + ticket_id: UUID of an existing ticket to clone from + """ + return self._send_and_transform_command(Tickets.clone_ticket(ticket_id)) + + def create_ticket( + self, + *, + result_id: EntityID, + assigned_to_user_id: EntityID, + note: str, + comment: Optional[str] = None, + ) -> T: + """Create a new ticket + + Args: + result_id: UUID of the result the ticket applies to + assigned_to_user_id: UUID of a user the ticket should be assigned to + note: A note about opening the ticket + comment: Comment for the ticket + """ + return self._send_and_transform_command( + Tickets.create_ticket( + result_id=result_id, + assigned_to_user_id=assigned_to_user_id, + note=note, + comment=comment, + ) + ) + + def delete_ticket( + self, ticket_id: EntityID, *, ultimate: Optional[bool] = False + ) -> T: + """Deletes an existing ticket + + Args: + ticket_id: UUID of the ticket to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + Tickets.delete_ticket(ticket_id, ultimate=ultimate) + ) + + def get_tickets( + self, + *, + trash: Optional[bool] = None, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + ) -> T: + """Request a list of tickets + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: True to request the tickets in the trashcan + """ + return self._send_and_transform_command( + Tickets.get_tickets( + filter_string=filter_string, filter_id=filter_id, trash=trash + ) + ) + + def get_ticket(self, ticket_id: EntityID) -> T: + """Request a single ticket + + Args: + ticket_id: UUID of an existing ticket + """ + return self._send_and_transform_command(Tickets.get_ticket(ticket_id)) + + def modify_ticket( + self, + ticket_id: EntityID, + *, + status: Optional[Union[TicketStatus, str]] = None, + note: Optional[str] = None, + assigned_to_user_id: Optional[EntityID] = None, + comment: Optional[str] = None, + ) -> T: + """Modify a single ticket + + Args: + ticket_id: UUID of an existing ticket + status: New status for the ticket + note: Note for the status change. Required if status is set. + assigned_to_user_id: UUID of the user the ticket should be assigned + to + comment: Comment for the ticket + """ + return self._send_and_transform_command( + Tickets.modify_ticket( + ticket_id, + status=status, + note=note, + assigned_to_user_id=assigned_to_user_id, + comment=comment, + ) + ) + + def clone_tls_certificate(self, tls_certificate_id: EntityID) -> T: + """Modifies an existing TLS certificate. + + Args: + tls_certificate_id: The UUID of an existing TLS certificate + """ + return self._send_and_transform_command( + TLSCertificates.clone_tls_certificate(tls_certificate_id) + ) + + def create_tls_certificate( + self, + name: str, + certificate: str, + *, + comment: Optional[str] = None, + trust: Optional[bool] = None, + ) -> T: + """Create a new TLS certificate + + Args: + name: Name of the TLS certificate, defaulting to the MD5 + fingerprint. + certificate: The Base64 encoded certificate data (x.509 DER or PEM). + comment: Comment for the TLS certificate. + trust: Whether the certificate is trusted. + """ + return self._send_and_transform_command( + TLSCertificates.create_tls_certificate( + name, certificate, comment=comment, trust=trust + ) + ) + + def delete_tls_certificate(self, tls_certificate_id: EntityID) -> T: + """Deletes an existing tls certificate + + Args: + tls_certificate_id: UUID of the tls certificate to be deleted. + """ + return self._send_and_transform_command( + TLSCertificates.delete_tls_certificate(tls_certificate_id) + ) + + def get_tls_certificates( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + include_certificate_data: Optional[bool] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of TLS certificates + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + include_certificate_data: Whether to include the certificate data in + the response + details: Whether to include additional details of the + tls certificates + """ + return self._send_and_transform_command( + TLSCertificates.get_tls_certificates( + filter_string=filter_string, + filter_id=filter_id, + include_certificate_data=include_certificate_data, + details=details, + ) + ) + + def get_tls_certificate(self, tls_certificate_id: EntityID) -> T: + """Request a single TLS certificate + + Args: + tls_certificate_id: UUID of an existing TLS certificate + """ + return self._send_and_transform_command( + TLSCertificates.get_tls_certificate(tls_certificate_id) + ) + + def modify_tls_certificate( + self, + tls_certificate_id: EntityID, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + trust: Optional[bool] = None, + ) -> T: + """Modifies an existing TLS certificate. + + Args: + tls_certificate_id: UUID of the TLS certificate to be modified. + name: Name of the TLS certificate, defaulting to the MD5 fingerprint + comment: Comment for the TLS certificate. + trust: Whether the certificate is trusted. + """ + return self._send_and_transform_command( + TLSCertificates.modify_tls_certificate( + tls_certificate_id, name=name, comment=comment, trust=trust + ) + ) + + def get_vulnerabilities( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + ) -> T: + """Request a list of vulnerabilities + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + """ + return self._send_and_transform_command( + Vulnerabilities.get_vulnerabilities( + filter_string=filter_string, filter_id=filter_id + ) + ) + + def get_vulnerability(self, vulnerability_id: EntityID) -> T: + """Request a single vulnerability + + Args: + vulnerability_id: ID of an existing vulnerability + """ + return self._send_and_transform_command( + Vulnerabilities.get_vulnerability(vulnerability_id) + ) + + def clone_report_format( + self, report_format_id: Union[EntityID, ReportFormatType] + ) -> T: + """Clone a report format from an existing one + + Args: + report_format_id: UUID of the existing report format + or ReportFormatType (enum) + """ + return self._send_and_transform_command( + ReportFormats.clone_report_format(report_format_id) + ) + + def delete_report_format( + self, + report_format_id: Union[EntityID, ReportFormatType], + *, + ultimate: Optional[bool] = False, + ) -> T: + """Deletes an existing report format + + Args: + report_format_id: UUID of the report format to be deleted. + or ReportFormatType (enum) + ultimate: Whether to remove entirely, or to the trashcan. + """ + return self._send_and_transform_command( + ReportFormats.delete_report_format( + report_format_id, ultimate=ultimate + ) + ) + + def get_report_formats( + self, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + alerts: Optional[bool] = None, + params: Optional[bool] = None, + details: Optional[bool] = None, + ) -> T: + """Request a list of report formats + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan report formats instead + alerts: Whether to include alerts that use the report format + params: Whether to include report format parameters + details: Include report format file, signature and parameters + """ + return self._send_and_transform_command( + ReportFormats.get_report_formats( + filter_string=filter_string, + filter_id=filter_id, + trash=trash, + alerts=alerts, + params=params, + details=details, + ) + ) + + def get_report_format( + self, report_format_id: Union[EntityID, ReportFormatType] + ) -> T: + """Request a single report format + + Args: + report_format_id: UUID of an existing report format + or ReportFormatType (enum) + """ + return self._send_and_transform_command( + ReportFormats.get_report_format(report_format_id) + ) + + def import_report_format(self, report_format: str) -> T: + """Import a report format from XML + + Args: + report_format: Report format XML as string to import. This XML must + contain a :code:`` root element. + """ + return self._send_and_transform_command( + ReportFormats.import_report_format(report_format) + ) + + def modify_report_format( + self, + report_format_id: Union[EntityID, ReportFormatType], + *, + active: Optional[bool] = None, + name: Optional[str] = None, + summary: Optional[str] = None, + param_name: Optional[str] = None, + param_value: Optional[str] = None, + ) -> T: + """Modifies an existing report format. + + Args: + report_format_id: UUID of report format to modify + or ReportFormatType (enum) + active: Whether the report format is active. + name: The name of the report format. + summary: A summary of the report format. + param_name: The name of the param. + param_value: The value of the param. + """ + return self._send_and_transform_command( + ReportFormats.modify_report_format( + report_format_id, + active=active, + name=name, + summary=summary, + param_name=param_name, + param_value=param_value, + ) + ) + + def verify_report_format( + self, report_format_id: Union[EntityID, ReportFormatType] + ) -> T: + """Verify an existing report format + + Verifies the trust level of an existing report format. It will be + checked whether the signature of the report format currently matches the + report format. This includes the script and files used to generate + reports of this format. It is *not* verified if the report format works + as expected by the user. + + Args: + report_format_id: UUID of the report format to be verified + or ReportFormatType (enum) + """ + return self._send_and_transform_command( + ReportFormats.verify_report_format(report_format_id) + ) diff --git a/gvm/protocols/gmp/_gmp225.py b/gvm/protocols/gmp/_gmp225.py new file mode 100644 index 000000000..1c90a6896 --- /dev/null +++ b/gvm/protocols/gmp/_gmp225.py @@ -0,0 +1,95 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +""" +Greenbone Management Protocol (GMP) version 22.5 +""" + +from typing import Optional + +from .._protocol import T +from ._gmp224 import GMPv224 +from .requests.v225 import ( + ResourceNames, + ResourceType, +) + + +class GMPv225(GMPv224[T]): + """ + A class implementing the Greenbone Management Protocol (GMP) version 22.5 + + Example: + + .. code-block:: python + + from gvm.protocols.gmp import GMPv225 as GMP + + with GMP(connection) as gmp: + resp = gmp.get_tasks() + """ + + def __init__(self, *args, **kwargs): + """ + Create a new GMPv225 instance. + + Args: + connection: Connection to use to talk with the remote daemon. See + :mod:`gvm.connections` for possible connection types. + transform: Optional transform `callable`_ to convert response data. + After each request the callable gets passed the plain response data + which can be used to check the data and/or conversion into different + representations like a xml dom. + + See :mod:`gvm.transforms` for existing transforms. + + .. _callable: + https://docs.python.org/3/library/functions.html#callable + """ + super().__init__(*args, **kwargs) + + @staticmethod + def get_protocol_version() -> tuple[int, int]: + return (22, 5) + + def get_resource_names( + self, + resource_type: ResourceType, + *, + filter_string: Optional[str] = None, + ) -> T: + """Request a list of resource names and IDs + + Arguments: + resource_type: Type must be either ALERT, CERT_BUND_ADV, + CONFIG, CPE, CREDENTIAL, CVE, DFN_CERT_ADV, FILTER, + GROUP, HOST, NOTE, NVT, OS, OVERRIDE, PERMISSION, + PORT_LIST, REPORT_FORMAT, REPORT, RESULT, ROLE, + SCANNER, SCHEDULE, TARGET, TASK, TLS_CERTIFICATE + or USER + filter_string: Filter term to use for the query + """ + return self._send_and_transform_command( + ResourceNames.get_resource_names( + resource_type, filter_string=filter_string + ) + ) + + def get_resource_name( + self, resource_id: str, resource_type: ResourceType + ) -> T: + """Request a single resource name + + Arguments: + resource_id: ID of an existing resource + resource_type: Type must be either ALERT, CERT_BUND_ADV, + CONFIG, CPE, CREDENTIAL, CVE, DFN_CERT_ADV, FILTER, + GROUP, HOST, NOTE, NVT, OS, OVERRIDE, PERMISSION, + PORT_LIST, REPORT_FORMAT, REPORT, RESULT, ROLE, + SCANNER, SCHEDULE, TARGET, TASK, TLS_CERTIFICATE + or USER + """ + return self._send_and_transform_command( + ResourceNames.get_resource_name(resource_id, resource_type) + ) diff --git a/gvm/protocols/gmp/requests/__init__.py b/gvm/protocols/gmp/requests/__init__.py new file mode 100644 index 000000000..118d97821 --- /dev/null +++ b/gvm/protocols/gmp/requests/__init__.py @@ -0,0 +1,11 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from ._entity_id import EntityID +from ._version import Version + +__all__ = ( + "EntityID", + "Version", +) diff --git a/gvm/protocols/gmp/requests/_entity_id.py b/gvm/protocols/gmp/requests/_entity_id.py new file mode 100644 index 000000000..4a3aa253a --- /dev/null +++ b/gvm/protocols/gmp/requests/_entity_id.py @@ -0,0 +1,8 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Union +from uuid import UUID + +EntityID = Union[str, UUID] diff --git a/gvm/protocols/gmp/requests/_version.py b/gvm/protocols/gmp/requests/_version.py new file mode 100644 index 000000000..c917cee24 --- /dev/null +++ b/gvm/protocols/gmp/requests/_version.py @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from gvm.protocols.core import Request +from gvm.xml import XmlCommand + + +class Version: + @staticmethod + def get_version() -> Request: + """Get the Greenbone Vulnerability Management Protocol (GMP) version + used by the remote gvmd. + """ + return XmlCommand("get_version") diff --git a/gvm/protocols/gmp/requests/v224/__init__.py b/gvm/protocols/gmp/requests/v224/__init__.py new file mode 100644 index 000000000..d3624501f --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/__init__.py @@ -0,0 +1,124 @@ +# SPDX-FileCopyrightText: 2018-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later +# +""" +GMP Request implementations for GMP version 22.4. +""" + +from .._entity_id import EntityID +from .._version import Version +from ._aggregates import Aggregates, AggregateStatistic, SortOrder +from ._alerts import AlertCondition, AlertEvent, AlertMethod, Alerts +from ._audits import Audits +from ._auth import Authentication +from ._cert_bund_advisories import CertBundAdvisories +from ._cpes import Cpes +from ._credentials import ( + CredentialFormat, + Credentials, + CredentialType, + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, +) +from ._cves import Cves +from ._dfn_cert_advisories import DfnCertAdvisories +from ._entity_type import EntityType +from ._feed import Feed, FeedType +from ._filters import Filters, FilterType +from ._groups import Groups +from ._help import Help, HelpFormat +from ._hosts import Hosts, HostsOrdering +from ._notes import Notes +from ._nvts import Nvts +from ._operating_systems import OperatingSystems +from ._overrides import Overrides +from ._permissions import Permissions, PermissionSubjectType +from ._policies import Policies +from ._port_lists import PortLists, PortRangeType +from ._report_formats import ReportFormats, ReportFormatType +from ._reports import Reports +from ._results import Results +from ._roles import Roles +from ._scan_configs import ScanConfigs +from ._scanners import Scanners, ScannerType +from ._schedules import Schedules +from ._secinfo import InfoType, SecInfo +from ._severity import Severity +from ._system_reports import SystemReports +from ._tags import Tags +from ._targets import AliveTest, Targets +from ._tasks import Tasks +from ._tickets import Tickets, TicketStatus +from ._tls_certificates import TLSCertificates +from ._trashcan import TrashCan +from ._user_settings import UserSettings +from ._users import UserAuthType, Users +from ._vulnerabilities import Vulnerabilities + +__all__ = ( + "Aggregates", + "AggregateStatistic", + "Alerts", + "AlertCondition", + "AlertEvent", + "AlertMethod", + "AliveTest", + "Audits", + "Authentication", + "CertBundAdvisories", + "Cpes", + "Credentials", + "CredentialFormat", + "CredentialType", + "Cves", + "DfnCertAdvisories", + "EntityID", + "EntityType", + "Feed", + "FeedType", + "Filters", + "FilterType", + "Groups", + "Help", + "HelpFormat", + "Hosts", + "HostsOrdering", + "InfoType", + "Notes", + "Nvts", + "OperatingSystems", + "Overrides", + "Permissions", + "PermissionSubjectType", + "Policies", + "PortLists", + "PortRangeType", + "ReportFormatType", + "ReportFormats", + "Reports", + "Results", + "Roles", + "ScanConfigs", + "Scanners", + "ScannerType", + "Schedules", + "SecInfo", + "Severity", + "SortOrder", + "SnmpAuthAlgorithm", + "SnmpPrivacyAlgorithm", + "SystemReports", + "Tags", + "Targets", + "Tasks", + "Tickets", + "TicketStatus", + "TLSCertificates", + "TrashCan", + "UserAuthType", + "UserSettings", + "Users", + "Version", + "Vulnerabilities", +) diff --git a/gvm/protocols/gmpv208/system/aggregates.py b/gvm/protocols/gmp/requests/v224/_aggregates.py similarity index 68% rename from gvm/protocols/gmpv208/system/aggregates.py rename to gvm/protocols/gmp/requests/v224/_aggregates.py index 03d7a4e02..ca70e4410 100644 --- a/gvm/protocols/gmpv208/system/aggregates.py +++ b/gvm/protocols/gmp/requests/v224/_aggregates.py @@ -1,18 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Iterable, Optional, Union from gvm._enum import Enum from gvm.errors import InvalidArgumentType, RequiredArgument - -# if I use latest, I get circular import :/ -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.utils import add_filter +from gvm.protocols.core import Request from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._entity_type import EntityType + class AggregateStatistic(Enum): """Enum for aggregate statistic types""" @@ -35,29 +34,32 @@ class SortOrder(Enum): DESCENDING = "descending" -class AggregatesMixin: +class Aggregates: + @classmethod def get_aggregates( - self, - resource_type: EntityType, + cls, + resource_type: Union[EntityType, str], *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - sort_criteria: Optional[list] = None, - data_columns: Optional[list] = None, + filter_id: Optional[EntityID] = None, + sort_criteria: Optional[ + Iterable[dict[str, Union[str, SortOrder, AggregateStatistic]]] + ] = None, + data_columns: Optional[Union[Iterable[str], str]] = None, group_column: Optional[str] = None, subgroup_column: Optional[str] = None, - text_columns: Optional[list] = None, + text_columns: Optional[Union[Iterable[str], str]] = None, first_group: Optional[int] = None, max_groups: Optional[int] = None, mode: Optional[int] = None, **kwargs, - ) -> Any: + ) -> Request: """Request aggregated information on a resource / entity type Additional arguments can be set via the kwargs parameter for backward compatibility with older versions of python-gvm, but are not validated. - Arguments: + Args: resource_type: The entity type to gather data from filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query @@ -73,21 +75,14 @@ def get_aggregates( max_groups: The maximum number of aggregate groups to return, -1 for all mode: Special mode for aggregation - - Returns: - The response. See :py:meth:`send_command` for details. """ if not resource_type: raise RequiredArgument( - function=self.get_aggregates.__name__, argument="resource_type" + function=cls.get_aggregates.__name__, argument="resource_type" ) if not isinstance(resource_type, EntityType): - raise InvalidArgumentType( - function=self.get_aggregates.__name__, - argument="resource_type", - arg_type=EntityType.__name__, - ) + resource_type = EntityType(resource_type) cmd = XmlCommand("get_aggregates") @@ -102,66 +97,71 @@ def get_aggregates( cmd.set_attribute("usage_type", "scan") elif resource_type.value == EntityType.TASK.value: cmd.set_attribute("usage_type", "scan") + cmd.set_attribute("type", _actual_resource_type.value) - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if first_group is not None: - if not isinstance(first_group, int): + try: + cmd.set_attribute("first_group", str(int(first_group))) + except ValueError: raise InvalidArgumentType( - function=self.get_aggregates.__name__, argument="first_group", - arg_type=int.__name__, - ) - cmd.set_attribute("first_group", str(first_group)) + function=cls.get_aggregates.__name__, + ) from None if max_groups is not None: - if not isinstance(max_groups, int): + try: + cmd.set_attribute("max_groups", str(int(max_groups))) + except ValueError: raise InvalidArgumentType( - function=self.get_aggregates.__name__, - argument="max_groups", - arg_type=int.__name__, + argument="first_group", + function=cls.get_aggregates.__name__, ) - cmd.set_attribute("max_groups", str(max_groups)) if sort_criteria is not None: - if not isinstance(sort_criteria, list): + if not isinstance(sort_criteria, Iterable) or isinstance( + sort_criteria, str + ): raise InvalidArgumentType( - function=self.get_aggregates.__name__, argument="sort_criteria", - arg_type=list.__name__, + function=cls.get_aggregates.__name__, + arg_type=getattr(Iterable, "__name__", "Iterable"), ) for sort in sort_criteria: if not isinstance(sort, dict): raise InvalidArgumentType( - function=self.get_aggregates.__name__, argument="sort_criteria", + function=cls.get_aggregates.__name__, ) sort_elem = cmd.add_element("sort") if sort.get("field"): - sort_elem.set_attribute("field", sort.get("field")) + sort_elem.set_attribute("field", sort.get("field")) # type: ignore if sort.get("stat"): if isinstance(sort["stat"], AggregateStatistic): sort_elem.set_attribute("stat", sort["stat"].value) else: - stat = AggregateStatistic.from_string(sort["stat"]) + stat = AggregateStatistic(sort["stat"]) sort_elem.set_attribute("stat", stat.value) if sort.get("order"): if isinstance(sort["order"], SortOrder): sort_elem.set_attribute("order", sort["order"].value) else: - so = SortOrder.from_string(sort["order"]) + so = SortOrder(sort["order"]) sort_elem.set_attribute("order", so.value) if data_columns is not None: - if not isinstance(data_columns, list): + if isinstance(data_columns, str): + data_columns = [data_columns] + elif not isinstance(data_columns, Iterable): raise InvalidArgumentType( - function=self.get_aggregates.__name__, + function=cls.get_aggregates.__name__, argument="data_columns", - arg_type=list.__name__, + arg_type=getattr(Iterable, "__name__", "Iterable"), ) for column in data_columns: cmd.add_element("data_column", column) @@ -172,27 +172,29 @@ def get_aggregates( if subgroup_column is not None: if not group_column: raise RequiredArgument( - f"{self.get_aggregates.__name__} requires a group_column" + f"{cls.get_aggregates.__name__} requires a group_column" " argument if subgroup_column is given", - function=self.get_aggregates.__name__, + function=cls.get_aggregates.__name__, argument="subgroup_column", ) cmd.set_attribute("subgroup_column", subgroup_column) if text_columns is not None: - if not isinstance(text_columns, list): + if isinstance(text_columns, str): + text_columns = [text_columns] + elif not isinstance(text_columns, Iterable): raise InvalidArgumentType( - function=self.get_aggregates.__name__, + function=cls.get_aggregates.__name__, argument="text_columns", - arg_type=list.__name__, + arg_type=getattr(Iterable, "__name__", "Iterable"), ) for column in text_columns: cmd.add_element("text_column", column) if mode is not None: - cmd.set_attribute("mode", mode) + cmd.set_attribute("mode", str(mode)) # Add additional keyword args as attributes for backward compatibility. cmd.set_attributes(kwargs) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/alerts.py b/gvm/protocols/gmp/requests/v224/_alerts.py similarity index 64% rename from gvm/protocols/gmpv208/entities/alerts.py rename to gvm/protocols/gmp/requests/v224/_alerts.py index af87196ba..31e436bb7 100644 --- a/gvm/protocols/gmpv208/entities/alerts.py +++ b/gvm/protocols/gmp/requests/v224/_alerts.py @@ -1,18 +1,18 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional, Union +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument - -# if I use latest, I get circular import :/ -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType -from gvm.utils import add_filter, to_bool +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._report_formats import ReportFormatType + class AlertEvent(Enum): """Enum for alert event types""" @@ -54,7 +54,9 @@ class AlertMethod(Enum): def _check_event( - event: AlertEvent, condition: AlertCondition, method: AlertMethod + event: AlertEvent, + condition: Optional[AlertCondition], + method: Optional[AlertMethod], ): if event == AlertEvent.TASK_RUN_STATUS_CHANGED: if not condition: @@ -128,41 +130,24 @@ def _check_event( ) -class AlertsMixin: - def clone_alert(self, alert_id: str) -> Any: - """Clone an existing alert - - Arguments: - alert_id: UUID of an existing alert to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not alert_id: - raise RequiredArgument( - function=self.clone_alert.__name__, argument="alert_id" - ) - - cmd = XmlCommand("create_alert") - cmd.add_element("copy", alert_id) - return self._send_xml_command(cmd) - +class Alerts: + @classmethod def create_alert( - self, + cls, name: str, condition: AlertCondition, event: AlertEvent, method: AlertMethod, *, - method_data: Optional[dict] = None, - event_data: Optional[dict] = None, - condition_data: Optional[dict] = None, - filter_id: Optional[int] = None, + method_data: Optional[dict[str, str]] = None, + event_data: Optional[dict[str, str]] = None, + condition_data: Optional[dict[str, str]] = None, + filter_id: Optional[EntityID] = None, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new alert - Arguments: + Args: name: Name of the new Alert condition: The condition that must be satisfied for the alert to occur; if the event is either 'Updated SecInfo arrived' or @@ -182,50 +167,33 @@ def create_alert( method_data: Data that defines the method filter_id: Filter to apply when executing alert comment: Comment for the alert - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_alert.__name__, argument="name" + function=cls.create_alert.__name__, argument="name" ) if not condition: raise RequiredArgument( - function=self.create_alert.__name__, argument="condition" + function=cls.create_alert.__name__, argument="condition" ) if not event: raise RequiredArgument( - function=self.create_alert.__name__, argument="event" + function=cls.create_alert.__name__, argument="event" ) if not method: raise RequiredArgument( - function=self.create_alert.__name__, argument="method" + function=cls.create_alert.__name__, argument="method" ) if not isinstance(condition, AlertCondition): - raise InvalidArgumentType( - function=self.create_alert.__name__, - argument="condition", - arg_type=AlertCondition.__name__, - ) - + condition = AlertCondition(condition) if not isinstance(event, AlertEvent): - raise InvalidArgumentType( - function=self.create_alert.__name__, - argument="even", - arg_type=AlertEvent.__name__, - ) - + event = AlertEvent(event) if not isinstance(method, AlertMethod): - raise InvalidArgumentType( - function=self.create_alert.__name__, - argument="method", - arg_type=AlertMethod.__name__, - ) + method = AlertMethod(method) _check_event(event, condition, method) @@ -236,22 +204,22 @@ def create_alert( if condition_data is not None: for key, value in condition_data.items(): - _data = conditions.add_element("data", value) - _data.add_element("name", key) + xml_data = conditions.add_element("data", value) + xml_data.add_element("name", key) events = cmd.add_element("event", event.value) if event_data is not None: for key, value in event_data.items(): - _data = events.add_element("data", value) - _data.add_element("name", key) + xml_data = events.add_element("data", value) + xml_data.add_element("name", key) methods = cmd.add_element("method", method.value) if method_data is not None: for key, value in method_data.items(): - _data = methods.add_element("data", value) - _data.add_element("name", key) + xml_data = methods.add_element("data", value) + xml_data.add_element("name", key) if filter_id: cmd.add_element("filter", attrs={"id": filter_id}) @@ -259,98 +227,26 @@ def create_alert( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) - - def delete_alert( - self, alert_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing alert - - Arguments: - alert_id: UUID of the alert to be deleted. - ultimate: Whether to remove entirely, or to the trashcan. - """ - if not alert_id: - raise RequiredArgument( - function=self.delete_alert.__name__, argument="alert_id" - ) - - cmd = XmlCommand("delete_alert") - cmd.set_attribute("alert_id", alert_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) - - return self._send_xml_command(cmd) - - def get_alerts( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - trash: Optional[bool] = None, - tasks: Optional[bool] = None, - ) -> Any: - """Request a list of alerts - - Arguments: - filter: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - trash: True to request the alerts in the trashcan - tasks: Whether to include the tasks using the alerts - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_alerts") - - add_filter(cmd, filter_string, filter_id) - - if trash is not None: - cmd.set_attribute("trash", to_bool(trash)) - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - return self._send_xml_command(cmd) - - def get_alert(self, alert_id: str, *, tasks: Optional[bool] = None) -> Any: - """Request a single alert - - Arguments: - alert_id: UUID of an existing alert - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_alerts") - - if not alert_id: - raise RequiredArgument( - function=self.get_alert.__name__, argument="alert_id" - ) - - cmd.set_attribute("alert_id", alert_id) - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_alert( - self, - alert_id: str, + cls, + alert_id: EntityID, *, name: Optional[str] = None, comment: Optional[str] = None, - filter_id: Optional[str] = None, - event: Optional[AlertEvent] = None, + filter_id: Optional[EntityID] = None, + event: Optional[Union[AlertEvent, str]] = None, event_data: Optional[dict] = None, - condition: Optional[AlertCondition] = None, - condition_data: Optional[dict] = None, - method: Optional[AlertMethod] = None, - method_data: Optional[dict] = None, - ) -> Any: - """Modifies an existing alert. - - Arguments: + condition: Optional[Union[AlertCondition, str]] = None, + condition_data: Optional[dict[str, str]] = None, + method: Optional[Union[AlertMethod, str]] = None, + method_data: Optional[dict[str, str]] = None, + ) -> Request: + """Modify an existing alert. + + Args: alert_id: UUID of the alert to be modified. name: Name of the Alert. condition: The condition that must be satisfied for the alert to @@ -371,14 +267,10 @@ def modify_alert( method_data: Data that defines the method filter_id: Filter to apply when executing alert comment: Comment for the alert - - Returns: - The response. See :py:meth:`send_command` for details. """ - if not alert_id: raise RequiredArgument( - function=self.modify_alert.__name__, argument="alert_id" + function=cls.modify_alert.__name__, argument="alert_id" ) cmd = XmlCommand("modify_alert") @@ -395,124 +287,191 @@ def modify_alert( if condition: if not isinstance(condition, AlertCondition): - raise InvalidArgumentType( - function=self.modify_alert.__name__, - argument="condition", - arg_type=AlertCondition.__name__, - ) + condition = AlertCondition(condition) conditions = cmd.add_element("condition", condition.value) if condition_data is not None: for key, value in condition_data.items(): - _data = conditions.add_element("data", value) - _data.add_element("name", key) + xml_data = conditions.add_element("data", value) + xml_data.add_element("name", key) if method: if not isinstance(method, AlertMethod): - raise InvalidArgumentType( - function=self.modify_alert.__name__, - argument="method", - arg_type=AlertMethod.__name__, - ) + method = AlertMethod(method) methods = cmd.add_element("method", method.value) if method_data is not None: for key, value in method_data.items(): - _data = methods.add_element("data", value) - _data.add_element("name", key) + xml_data = methods.add_element("data", value) + xml_data.add_element("name", key) if event: if not isinstance(event, AlertEvent): - raise InvalidArgumentType( - function=self.modify_alert.__name__, - argument="event", - arg_type=AlertEvent.__name__, - ) + event = AlertEvent(event) - _check_event(event, condition, method) + _check_event(event, condition, method) # type: ignore events = cmd.add_element("event", event.value) if event_data is not None: for key, value in event_data.items(): - _data = events.add_element("data", value) - _data.add_element("name", key) + xml_data = events.add_element("data", value) + xml_data.add_element("name", key) + + return cmd - return self._send_xml_command(cmd) + @classmethod + def clone_alert(cls, alert_id: EntityID) -> Request: + """Clone an existing alert - def test_alert(self, alert_id: str) -> Any: + Args: + alert_id: UUID of the alert to clone from + """ + if not alert_id: + raise RequiredArgument( + function=cls.clone_alert.__name__, argument="alert_id" + ) + + cmd = XmlCommand("create_alert") + cmd.add_element("copy", str(alert_id)) + return cmd + + @classmethod + def delete_alert( + cls, alert_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing alert + + Args: + alert_id: UUID of the alert to delete + ultimate: Whether to remove entirely or to the trashcan. + """ + if not alert_id: + raise RequiredArgument( + function=cls.delete_alert.__name__, argument="alert_id" + ) + + cmd = XmlCommand("delete_alert") + cmd.set_attribute("alert_id", str(alert_id)) + cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd + + @classmethod + def test_alert(cls, alert_id: EntityID) -> Request: """Run an alert Invoke a test run of an alert - Arguments: + Args: alert_id: UUID of the alert to be tested - - Returns: - The response. See :py:meth:`send_command` for details. """ if not alert_id: - raise InvalidArgument("test_alert requires an alert_id argument") + raise RequiredArgument( + function=cls.test_alert.__name__, argument="alert_id" + ) cmd = XmlCommand("test_alert") - cmd.set_attribute("alert_id", alert_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("alert_id", str(alert_id)) + return cmd + @classmethod def trigger_alert( - self, - alert_id: str, - report_id: str, + cls, + alert_id: EntityID, + report_id: EntityID, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - report_format_id: Optional[Union[str, ReportFormatType]] = None, - delta_report_id: Optional[str] = None, - ) -> Any: + filter_id: Optional[EntityID] = None, + report_format_id: Optional[Union[EntityID, ReportFormatType]] = None, + delta_report_id: Optional[EntityID] = None, + ) -> Request: """Run an alert by ignoring its event and conditions The alert is triggered to run immediately with the provided filtered report by ignoring the even and condition settings. - Arguments: + Args: alert_id: UUID of the alert to be run report_id: UUID of the report to be provided to the alert filter: Filter term to use to filter results in the report filter_id: UUID of filter to use to filter results in the report - report_format_id: UUID of report format to use - or ReportFormatType (enum) + report_format_id: UUID of report format to use or ReportFormatType (enum) delta_report_id: UUID of an existing report to compare report to. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not alert_id: raise RequiredArgument( - function=self.trigger_alert.__name__, + function=cls.trigger_alert.__name__, argument="alert_id argument", ) if not report_id: raise RequiredArgument( - function=self.trigger_alert.__name__, + function=cls.trigger_alert.__name__, argument="report_id argument", ) cmd = XmlCommand("get_reports") - cmd.set_attribute("report_id", report_id) - cmd.set_attribute("alert_id", alert_id) - - add_filter(cmd, filter_string, filter_id) + cmd.set_attribute("report_id", str(report_id)) + cmd.set_attribute("alert_id", str(alert_id)) + cmd.add_filter(filter_string, filter_id) if report_format_id: - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.set_attribute("format_id", report_format_id) + cmd.set_attribute("format_id", str(report_format_id)) if delta_report_id: - cmd.set_attribute("delta_report_id", delta_report_id) + cmd.set_attribute("delta_report_id", str(delta_report_id)) + + return cmd + + @staticmethod + def get_alerts( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> Request: + """Request a list of alerts + + Args: + filter: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: True to request the alerts in the trashcan + tasks: Whether to include the tasks using the alerts + """ + cmd = XmlCommand("get_alerts") + cmd.add_filter(filter_string, filter_id) + + if trash is not None: + cmd.set_attribute("trash", to_bool(trash)) + + if tasks is not None: + cmd.set_attribute("tasks", to_bool(tasks)) + + return cmd + + @classmethod + def get_alert( + cls, alert_id: EntityID, *, tasks: Optional[bool] = None + ) -> Request: + """Request a single alert + + Arguments: + alert_id: UUID of an existing alert + tasks: Whether to include the tasks using the alert + """ + cmd = XmlCommand("get_alerts") + + if not alert_id: + raise RequiredArgument( + function=cls.get_alert.__name__, argument="alert_id" + ) + + cmd.set_attribute("alert_id", str(alert_id)) + + if tasks is not None: + cmd.set_attribute("tasks", to_bool(tasks)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/audits.py b/gvm/protocols/gmp/requests/v224/_audits.py similarity index 52% rename from gvm/protocols/gmpv208/entities/audits.py rename to gvm/protocols/gmp/requests/v224/_audits.py index 3ee7b838e..a6e685100 100644 --- a/gvm/protocols/gmpv208/entities/audits.py +++ b/gvm/protocols/gmp/requests/v224/_audits.py @@ -1,56 +1,40 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from collections.abc import Mapping from numbers import Integral -from typing import Any, List, Optional +from typing import Optional, Union -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering -from gvm.utils import add_filter, is_list_like, to_bool, to_comma_list +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._hosts import HostsOrdering -class AuditsMixin: - def clone_audit(self, audit_id: str) -> Any: - """Clone an existing audit - - Arguments: - audit_id: UUID of existing audit to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not audit_id: - raise RequiredArgument( - function=self.clone_audit.__name__, argument="audit_id" - ) - - cmd = XmlCommand("create_task") - cmd.add_element("copy", audit_id) - return self._send_xml_command(cmd) +class Audits: + @classmethod def create_audit( - self, + cls, name: str, - policy_id: str, - target_id: str, - scanner_id: str, + policy_id: EntityID, + target_id: EntityID, + scanner_id: EntityID, *, alterable: Optional[bool] = None, - hosts_ordering: Optional[HostsOrdering] = None, + hosts_ordering: Optional[Union[HostsOrdering, str]] = None, schedule_id: Optional[str] = None, - alert_ids: Optional[List[str]] = None, + alert_ids: Optional[list[EntityID]] = None, comment: Optional[str] = None, schedule_periods: Optional[int] = None, - observers: Optional[List[str]] = None, - preferences: Optional[dict] = None, - ) -> Any: - """Create a new audit task + observers: Optional[list[EntityID]] = None, + preferences: Optional[dict[str, str]] = None, + ) -> Request: + """Create a new audit - Arguments: + Args: name: Name of the new audit policy_id: UUID of policy to use by the audit target_id: UUID of target to be scanned @@ -65,42 +49,39 @@ def create_audit( observers: List of names or ids of users which should be allowed to observe this audit preferences: Name/Value pairs of scanner preferences. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_audit.__name__, argument="name" + function=cls.create_audit.__name__, argument="name" ) if not policy_id: raise RequiredArgument( - function=self.create_audit.__name__, argument="policy_id" + function=cls.create_audit.__name__, argument="policy_id" ) if not target_id: raise RequiredArgument( - function=self.create_audit.__name__, argument="target_id" + function=cls.create_audit.__name__, argument="target_id" ) if not scanner_id: raise RequiredArgument( - function=self.create_audit.__name__, argument="scanner_id" + function=cls.create_audit.__name__, argument="scanner_id" ) # don't allow to create a container task with create_task if target_id == "0": raise InvalidArgument( - function=self.create_audit.__name__, argument="target_id" + function=cls.create_audit.__name__, argument="target_id" ) cmd = XmlCommand("create_task") cmd.add_element("name", name) cmd.add_element("usage_type", "audit") - cmd.add_element("config", attrs={"id": policy_id}) - cmd.add_element("target", attrs={"id": target_id}) - cmd.add_element("scanner", attrs={"id": scanner_id}) + cmd.add_element("config", attrs={"id": str(policy_id)}) + cmd.add_element("target", attrs={"id": str(target_id)}) + cmd.add_element("scanner", attrs={"id": str(scanner_id)}) if comment: cmd.add_element("comment", comment) @@ -110,27 +91,15 @@ def create_audit( if hosts_ordering: if not isinstance(hosts_ordering, HostsOrdering): - raise InvalidArgumentType( - function=self.create_audit.__name__, - argument="hosts_ordering", - arg_type=HostsOrdering.__name__, - ) + hosts_ordering = HostsOrdering(hosts_ordering) cmd.add_element("hosts_ordering", hosts_ordering.value) - if alert_ids is not None: - if not is_list_like(alert_ids): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="alert_ids", - arg_type="list", - ) - - if not len(alert_ids) == 0: - for alert in alert_ids: - cmd.add_element("alert", attrs={"id": str(alert)}) + if alert_ids: + for alert in alert_ids: + cmd.add_element("alert", attrs={"id": str(alert)}) if schedule_id: - cmd.add_element("schedule", attrs={"id": schedule_id}) + cmd.add_element("schedule", attrs={"id": str(schedule_id)}) if schedule_periods is not None: if ( @@ -143,135 +112,42 @@ def create_audit( ) cmd.add_element("schedule_periods", str(schedule_periods)) - if observers is not None: - if not is_list_like(observers): - raise InvalidArgumentType( - function=self.create_audit.__name__, - argument="observers", - arg_type="list", - ) - + if observers: # gvmd splits by comma and space # gvmd tries to lookup each value as user name and afterwards as # user id. So both user name and user id are possible cmd.add_element("observers", to_comma_list(observers)) if preferences is not None: - if not isinstance(preferences, Mapping): - raise InvalidArgumentType( - function=self.create_audit.__name__, - argument="preferences", - arg_type=Mapping.__name__, - ) - - _xmlprefs = cmd.add_element("preferences") + xml_prefs = cmd.add_element("preferences") for pref_name, pref_value in preferences.items(): - _xmlpref = _xmlprefs.add_element("preference") - _xmlpref.add_element("scanner_name", pref_name) - _xmlpref.add_element("value", str(pref_value)) - - return self._send_xml_command(cmd) - - def delete_audit( - self, audit_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing audit - - Arguments: - audit_id: UUID of the audit to be deleted. - ultimate: Whether to remove entirely, or to the trashcan. - """ - if not audit_id: - raise RequiredArgument( - function=self.delete_audit.__name__, argument="audit_id" - ) - - cmd = XmlCommand("delete_task") - cmd.set_attribute("task_id", audit_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) + xml_pref = xml_prefs.add_element("preference") + xml_pref.add_element("scanner_name", pref_name) + xml_pref.add_element("value", str(pref_value)) - return self._send_xml_command(cmd) - - def get_audits( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - trash: Optional[bool] = None, - details: Optional[bool] = None, - schedules_only: Optional[bool] = None, - ) -> Any: - """Request a list of audits - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - trash: Whether to get the trashcan audits instead - details: Whether to include full audit details - schedules_only: Whether to only include id, name and schedule - details - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_tasks") - cmd.set_attribute("usage_type", "audit") - - add_filter(cmd, filter_string, filter_id) - - if trash is not None: - cmd.set_attribute("trash", to_bool(trash)) - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - if schedules_only is not None: - cmd.set_attribute("schedules_only", to_bool(schedules_only)) - - return self._send_xml_command(cmd) - - def get_audit(self, audit_id: str) -> Any: - """Request a single audit - - Arguments: - audit_id: UUID of an existing audit - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not audit_id: - raise RequiredArgument( - function=self.get_task.__name__, argument="audit_id" - ) - - cmd = XmlCommand("get_tasks") - cmd.set_attribute("task_id", audit_id) - cmd.set_attribute("usage_type", "audit") - - # for single entity always request all details - cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_audit( - self, - audit_id: str, + cls, + audit_id: EntityID, *, name: Optional[str] = None, - policy_id: Optional[str] = None, - target_id: Optional[str] = None, - scanner_id: Optional[str] = None, + policy_id: Optional[EntityID] = None, + target_id: Optional[EntityID] = None, + scanner_id: Optional[EntityID] = None, alterable: Optional[bool] = None, - hosts_ordering: Optional[HostsOrdering] = None, - schedule_id: Optional[str] = None, + hosts_ordering: Optional[Union[str, HostsOrdering]] = None, + schedule_id: Optional[EntityID] = None, schedule_periods: Optional[int] = None, comment: Optional[str] = None, - alert_ids: Optional[List[str]] = None, - observers: Optional[List[str]] = None, - preferences: Optional[dict] = None, - ) -> Any: - """Modifies an existing task. + alert_ids: Optional[list[EntityID]] = None, + observers: Optional[list[EntityID]] = None, + preferences: Optional[dict[str, str]] = None, + ) -> Request: + """Modifies an existing audit. - Arguments: + Args: audit_id: UUID of audit to modify. name: The name of the audit. policy_id: UUID of policy to use by the audit @@ -286,17 +162,14 @@ def modify_audit( observers: List of names or ids of users which should be allowed to observe this audit preferences: Name/Value pairs of scanner preferences. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not audit_id: raise RequiredArgument( - function=self.modify_task.__name__, argument="task_id argument" + function=cls.modify_audit.__name__, argument="task_id argument" ) cmd = XmlCommand("modify_task") - cmd.set_attribute("task_id", audit_id) + cmd.set_attribute("task_id", str(audit_id)) if name: cmd.add_element("name", name) @@ -305,28 +178,24 @@ def modify_audit( cmd.add_element("comment", comment) if policy_id: - cmd.add_element("config", attrs={"id": policy_id}) + cmd.add_element("config", attrs={"id": str(policy_id)}) if target_id: - cmd.add_element("target", attrs={"id": target_id}) + cmd.add_element("target", attrs={"id": str(target_id)}) if alterable is not None: cmd.add_element("alterable", to_bool(alterable)) if hosts_ordering: if not isinstance(hosts_ordering, HostsOrdering): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="hosts_ordering", - arg_type=HostsOrdering.__name__, - ) + hosts_ordering = HostsOrdering(hosts_ordering) cmd.add_element("hosts_ordering", hosts_ordering.value) if scanner_id: - cmd.add_element("scanner", attrs={"id": scanner_id}) + cmd.add_element("scanner", attrs={"id": str(scanner_id)}) if schedule_id: - cmd.add_element("schedule", attrs={"id": schedule_id}) + cmd.add_element("schedule", attrs={"id": str(schedule_id)}) if schedule_periods is not None: if ( @@ -340,13 +209,6 @@ def modify_audit( cmd.add_element("schedule_periods", str(schedule_periods)) if alert_ids is not None: - if not is_list_like(alert_ids): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="alert_ids", - arg_type="list", - ) - if len(alert_ids) == 0: cmd.add_element("alert", attrs={"id": "0"}) else: @@ -354,84 +216,151 @@ def modify_audit( cmd.add_element("alert", attrs={"id": str(alert)}) if observers is not None: - if not is_list_like(observers): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="observers", - arg_type="list", - ) - cmd.add_element("observers", to_comma_list(observers)) if preferences is not None: - if not isinstance(preferences, Mapping): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="preferences", - arg_type=Mapping.__name__, - ) - - _xmlprefs = cmd.add_element("preferences") + xml_prefs = cmd.add_element("preferences") for pref_name, pref_value in preferences.items(): - _xmlpref = _xmlprefs.add_element("preference") - _xmlpref.add_element("scanner_name", pref_name) - _xmlpref.add_element("value", str(pref_value)) + xml_pref = xml_prefs.add_element("preference") + xml_pref.add_element("scanner_name", pref_name) + xml_pref.add_element("value", str(pref_value)) + + return cmd + + @classmethod + def clone_audit(cls, audit_id: EntityID) -> Request: + """Clone an existing audit + + Args: + audit_id: UUID of the audit to clone + """ + if not audit_id: + raise RequiredArgument( + function=cls.clone_audit.__name__, argument="task_id" + ) + + cmd = XmlCommand("create_task") + cmd.add_element("copy", str(audit_id)) + return cmd - return self._send_xml_command(cmd) + @classmethod + def delete_audit( + cls, audit_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing audit + + Args: + audit_id: UUID of the audit to be deleted. + ultimate: Whether to remove entirely, or to the trashcan. + """ + if not audit_id: + raise RequiredArgument( + function=cls.delete_audit.__name__, argument="task_id" + ) + + cmd = XmlCommand("delete_task") + cmd.set_attribute("task_id", str(audit_id)) + cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd + + @staticmethod + def get_audits( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + details: Optional[bool] = None, + schedules_only: Optional[bool] = None, + ) -> Request: + """Request a list of audits - def resume_audit(self, audit_id: str) -> Any: + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + trash: Whether to get the trashcan audits instead + details: Whether to include full audit details + schedules_only: Whether to only include id, name and schedule + details + """ + cmd = XmlCommand("get_tasks") + cmd.set_attribute("usage_type", "audit") + cmd.add_filter(filter_string, filter_id) + + if trash is not None: + cmd.set_attribute("trash", to_bool(trash)) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + if schedules_only is not None: + cmd.set_attribute("schedules_only", to_bool(schedules_only)) + + return cmd + + @classmethod + def get_audit(cls, audit_id: EntityID) -> Request: + """Request a single audit + + Args: + audit_id: UUID of an existing audit + """ + if not audit_id: + raise RequiredArgument( + function=cls.get_audit.__name__, argument="audit_id" + ) + + cmd = XmlCommand("get_tasks") + cmd.set_attribute("task_id", str(audit_id)) + cmd.set_attribute("usage_type", "audit") + + # for single entity always request all details + cmd.set_attribute("details", "1") + return cmd + + @classmethod + def resume_audit(cls, audit_id: EntityID) -> Request: """Resume an existing stopped audit - Arguments: + Args: audit_id: UUID of the audit to be resumed - - Returns: - The response. See :py:meth:`send_command` for details. """ if not audit_id: raise RequiredArgument( - function=self.resume_audit.__name__, argument="audit_id" + function=cls.resume_audit.__name__, argument="audit_id" ) cmd = XmlCommand("resume_task") - cmd.set_attribute("task_id", audit_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(audit_id)) + return cmd - def start_audit(self, audit_id: str) -> Any: + @classmethod + def start_audit(cls, audit_id: EntityID) -> Request: """Start an existing audit - Arguments: + Args: audit_id: UUID of the audit to be started - - Returns: - The response. See :py:meth:`send_command` for details. """ if not audit_id: raise RequiredArgument( - function=self.start_audit.__name__, argument="audit_id" + function=cls.start_audit.__name__, argument="audit_id" ) cmd = XmlCommand("start_task") - cmd.set_attribute("task_id", audit_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(audit_id)) + return cmd - def stop_audit(self, audit_id: str) -> Any: + @classmethod + def stop_audit(cls, audit_id: EntityID) -> Request: """Stop an existing running audit - Arguments: + Args: audit_id: UUID of the audit to be stopped - - Returns: - The response. See :py:meth:`send_command` for details. """ if not audit_id: raise RequiredArgument( - function=self.stop_audit.__name__, argument="audit_id" + function=cls.stop_audit.__name__, argument="audit_id" ) cmd = XmlCommand("stop_task") - cmd.set_attribute("task_id", audit_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(audit_id)) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_auth.py b/gvm/protocols/gmp/requests/v224/_auth.py new file mode 100644 index 000000000..a607b5dbe --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_auth.py @@ -0,0 +1,77 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.xml import XmlCommand + + +class Authentication: + + @classmethod + def authenticate(cls, username: str, password: str) -> Request: + """Authenticate to gvmd. + + The generated authenticate command will be send to server. + Afterwards the response is read, transformed and returned. + + Args: + username: Username + password: Password + """ + cmd = XmlCommand("authenticate") + + if not username: + raise RequiredArgument( + function=cls.authenticate.__name__, argument="username" + ) + + if not password: + raise RequiredArgument( + function=cls.authenticate.__name__, argument="password" + ) + + credentials = cmd.add_element("credentials") + credentials.add_element("username", username) + credentials.add_element("password", password) + return cmd + + @staticmethod + def describe_auth() -> Request: + """Describe authentication methods + + Returns a list of all used authentication methods if such a list is + available. + """ + return XmlCommand("describe_auth") + + @classmethod + def modify_auth( + cls, group_name: str, auth_conf_settings: dict[str, str] + ) -> Request: + """Modifies an existing authentication. + + Args: + group_name: Name of the group to be modified. + auth_conf_settings: The new auth config. + """ + if not group_name: + raise RequiredArgument( + function=cls.modify_auth.__name__, argument="group_name" + ) + if not auth_conf_settings: + raise RequiredArgument( + function=cls.modify_auth.__name__, + argument="auth_conf_settings", + ) + + cmd = XmlCommand("modify_auth") + group = cmd.add_element("group", attrs={"name": str(group_name)}) + + for key, value in auth_conf_settings.items(): + auth_conf = group.add_element("auth_conf_setting") + auth_conf.add_element("key", key) + auth_conf.add_element("value", value) + + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_cert_bund_advisories.py b/gvm/protocols/gmp/requests/v224/_cert_bund_advisories.py new file mode 100644 index 000000000..c19880587 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_cert_bund_advisories.py @@ -0,0 +1,67 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class CertBundAdvisories: + + @staticmethod + def get_cert_bund_advisories( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> Request: + """Request a list of CERT-BUND Advisories + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", "CERT_BUND_ADV") + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd + + @classmethod + def get_cert_bund_advisory(cls, cert_id: EntityID) -> Request: + """Request a single CERT-BUND Advisory + + Args: + cert_id: ID of an existing CERT-BUND Advisory + """ + if not cert_id: + raise RequiredArgument( + function=cls.get_cert_bund_advisory.__name__, argument="cert_id" + ) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", str(cert_id)) + cmd.set_attribute("type", "CERT_BUND_ADV") + + # for single entity always request all details + cmd.set_attribute("details", "1") + + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_cpes.py b/gvm/protocols/gmp/requests/v224/_cpes.py new file mode 100644 index 000000000..ae57a84f7 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_cpes.py @@ -0,0 +1,68 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class Cpes: + + @staticmethod + def get_cpes( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> Request: + """Request a list of CPEs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", "CPE") + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd + + @classmethod + def get_cpe(cls, cpe_id: str) -> Request: + """Request a single CPE + + Args: + cpe_id: ID of an existing CPE + """ + if not cpe_id: + raise RequiredArgument( + function=cls.get_cpe.__name__, argument="cpe_id" + ) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", cpe_id) + + cmd.set_attribute("type", "CPE") + + # for single entity always request all details + cmd.set_attribute("details", "1") + + return cmd diff --git a/gvm/protocols/gmpv208/entities/credentials.py b/gvm/protocols/gmp/requests/v224/_credentials.py similarity index 71% rename from gvm/protocols/gmpv208/entities/credentials.py rename to gvm/protocols/gmp/requests/v224/_credentials.py index d02e32cb7..ccf011057 100644 --- a/gvm/protocols/gmpv208/entities/credentials.py +++ b/gvm/protocols/gmp/requests/v224/_credentials.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class CredentialFormat(Enum): """Enum for credential format""" @@ -47,30 +49,29 @@ class SnmpPrivacyAlgorithm(Enum): DES = "des" -class CredentialsMixin: - def clone_credential(self, credential_id: str) -> Any: - """Clone an existing credential - - Arguments: - credential_id: UUID of an existing credential to clone from +class Credentials: + @classmethod + def clone_credential(cls, credential_id: EntityID) -> Request: + """Clone a credential - Returns: - The response. See :py:meth:`send_command` for details. + Args: + credential_id: The ID of the credential to clone """ if not credential_id: raise RequiredArgument( - function=self.clone_credential.__name__, + function=cls.clone_credential.__name__, argument="credential_id", ) cmd = XmlCommand("create_credential") - cmd.add_element("copy", credential_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(credential_id)) + return cmd + @classmethod def create_credential( - self, + cls, name: str, - credential_type: CredentialType, + credential_type: Union[CredentialType, str], *, comment: Optional[str] = None, allow_insecure: Optional[bool] = None, @@ -79,12 +80,12 @@ def create_credential( private_key: Optional[str] = None, login: Optional[str] = None, password: Optional[str] = None, - auth_algorithm: Optional[SnmpAuthAlgorithm] = None, + auth_algorithm: Optional[Union[SnmpAuthAlgorithm, str]] = None, community: Optional[str] = None, - privacy_algorithm: Optional[SnmpPrivacyAlgorithm] = None, + privacy_algorithm: Optional[Union[SnmpPrivacyAlgorithm, str]] = None, privacy_password: Optional[str] = None, public_key: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new credential Create a new credential e.g. to be used in the method of an alert. @@ -129,7 +130,7 @@ def create_credential( .. code-block:: python - gmp.create_credential( + request = Credentials.create_credential( name='UP Credential', credential_type=CredentialType.USERNAME_PASSWORD, login='foo', @@ -143,7 +144,7 @@ def create_credential( with open('path/to/private-ssh-key') as f: key = f.read() - gmp.create_credential( + request = Credentials.create_credential( name='USK Credential', credential_type=CredentialType.USERNAME_SSH_KEY, login='foo', @@ -165,7 +166,7 @@ def create_credential( with open('path/to/pgp.key.asc') as f: key = f.read() - gmp.create_credential( + request = Credentials.create_credential( name='PGP Credential', credential_type=CredentialType.PGP_ENCRYPTION_KEY, public_key=key, @@ -178,7 +179,7 @@ def create_credential( with open('path/to/smime-cert') as f: cert = f.read() - gmp.create_credential( + request = Credentials.create_credential( name='SMIME Credential', credential_type=CredentialType.SMIME_CERTIFICATE, certificate=cert, @@ -188,26 +189,26 @@ def create_credential( .. code-block:: python - gmp.create_credential( + request = Credentials.create_credential( name='Password-Only Credential', credential_type=CredentialType.PASSWORD_ONLY, password='foo', ) - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_credential.__name__, argument="name" + function=cls.create_credential.__name__, argument="name" ) - if not isinstance(credential_type, CredentialType): - raise InvalidArgumentType( - function=self.create_credential.__name__, + if not credential_type: + raise RequiredArgument( + function=cls.create_credential.__name__, argument="credential_type", - arg_type=CredentialType.__name__, ) + if not isinstance(credential_type, CredentialType): + credential_type = CredentialType(credential_type) + cmd = XmlCommand("create_credential") cmd.add_element("name", name) @@ -225,7 +226,7 @@ def create_credential( ): if not certificate: raise RequiredArgument( - function=self.create_credential.__name__, + function=cls.create_credential.__name__, argument="certificate", ) @@ -238,14 +239,14 @@ def create_credential( ): if not login: raise RequiredArgument( - function=self.create_credential.__name__, argument="login" + function=cls.create_credential.__name__, argument="login" ) cmd.add_element("login", login) if credential_type == CredentialType.PASSWORD_ONLY and not password: raise RequiredArgument( - function=self.create_credential.__name__, argument="password" + function=cls.create_credential.__name__, argument="password" ) if ( @@ -258,27 +259,28 @@ def create_credential( if credential_type == CredentialType.USERNAME_SSH_KEY: if not private_key: raise RequiredArgument( - function=self.create_credential.__name__, + function=cls.create_credential.__name__, argument="private_key", ) - _xmlkey = cmd.add_element("key") - _xmlkey.add_element("private", private_key) + xml_key = cmd.add_element("key") + xml_key.add_element("private", private_key) if key_phrase: - _xmlkey.add_element("phrase", key_phrase) + xml_key.add_element("phrase", key_phrase) if credential_type == CredentialType.CLIENT_CERTIFICATE and private_key: - _xmlkey = cmd.add_element("key") - _xmlkey.add_element("private", private_key) + xml_key = cmd.add_element("key") + xml_key.add_element("private", private_key) if credential_type == CredentialType.SNMP: - if not isinstance(auth_algorithm, SnmpAuthAlgorithm): - raise InvalidArgumentType( - function=self.create_credential.__name__, + if not auth_algorithm: + raise RequiredArgument( + function=cls.create_credential.__name__, argument="auth_algorithm", - arg_type=SnmpAuthAlgorithm.__name__, ) + if not isinstance(auth_algorithm, SnmpAuthAlgorithm): + auth_algorithm = SnmpAuthAlgorithm(auth_algorithm) cmd.add_element("auth_algorithm", auth_algorithm.value) @@ -286,65 +288,63 @@ def create_credential( cmd.add_element("community", community) if privacy_algorithm is not None or privacy_password: - _xmlprivacy = cmd.add_element("privacy") + xml_privacy = cmd.add_element("privacy") if privacy_algorithm is not None: if not isinstance(privacy_algorithm, SnmpPrivacyAlgorithm): - raise InvalidArgumentType( - function=self.create_credential.__name__, - argument="privacy_algorithm", - arg_type=SnmpPrivacyAlgorithm.__name__, + privacy_algorithm = SnmpPrivacyAlgorithm( + privacy_algorithm ) - _xmlprivacy.add_element( + xml_privacy.add_element( "algorithm", privacy_algorithm.value ) if privacy_password: - _xmlprivacy.add_element("password", privacy_password) + xml_privacy.add_element("password", privacy_password) if credential_type == CredentialType.PGP_ENCRYPTION_KEY: if not public_key: raise RequiredArgument( - function=self.create_credential.__name__, + function=cls.create_credential.__name__, argument="public_key", ) - _xmlkey = cmd.add_element("key") - _xmlkey.add_element("public", public_key) + xml_key = cmd.add_element("key") + xml_key.add_element("public", public_key) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_credential( - self, credential_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing credential + cls, credential_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete a credential - Arguments: - credential_id: UUID of the credential to be deleted. + Args: + credential_id: The ID of the credential to delete ultimate: Whether to remove entirely, or to the trashcan. """ if not credential_id: raise RequiredArgument( - function=self.delete_credential.__name__, + function=cls.delete_credential.__name__, argument="credential_id", ) cmd = XmlCommand("delete_credential") - cmd.set_attribute("credential_id", credential_id) + cmd.set_attribute("credential_id", str(credential_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd - return self._send_xml_command(cmd) - + @staticmethod def get_credentials( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, scanners: Optional[bool] = None, trash: Optional[bool] = None, targets: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of credentials Arguments: @@ -354,13 +354,10 @@ def get_credentials( credentials trash: Whether to get the trashcan credentials instead targets: Whether to include a list of targets using the credentials - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_credentials") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if scanners is not None: cmd.set_attribute("scanners", to_bool(scanners)) @@ -371,16 +368,17 @@ def get_credentials( if targets is not None: cmd.set_attribute("targets", to_bool(targets)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_credential( - self, - credential_id: str, + cls, + credential_id: EntityID, *, scanners: Optional[bool] = None, targets: Optional[bool] = None, - credential_format: Optional[CredentialFormat] = None, - ) -> Any: + credential_format: Optional[Union[CredentialFormat, str]] = None, + ) -> Request: """Request a single credential Arguments: @@ -389,25 +387,18 @@ def get_credential( credentials targets: Whether to include a list of targets using the credentials credential_format: One of "key", "rpm", "deb", "exe" or "pem" - - Returns: - The response. See :py:meth:`send_command` for details. """ if not credential_id: raise RequiredArgument( - function=self.get_credential.__name__, argument="credential_id" + function=cls.get_credential.__name__, argument="credential_id" ) cmd = XmlCommand("get_credentials") - cmd.set_attribute("credential_id", credential_id) + cmd.set_attribute("credential_id", str(credential_id)) if credential_format: if not isinstance(credential_format, CredentialFormat): - raise InvalidArgumentType( - function=self.get_credential.__name__, - argument="credential_format", - arg_type=CredentialFormat.__name__, - ) + credential_format = CredentialFormat(credential_format) cmd.set_attribute("format", credential_format.value) @@ -417,11 +408,12 @@ def get_credential( if targets is not None: cmd.set_attribute("targets", to_bool(targets)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_credential( - self, - credential_id: str, + cls, + credential_id: EntityID, *, name: Optional[str] = None, comment: Optional[str] = None, @@ -431,12 +423,12 @@ def modify_credential( private_key: Optional[str] = None, login: Optional[str] = None, password: Optional[str] = None, - auth_algorithm: Optional[SnmpAuthAlgorithm] = None, + auth_algorithm: Optional[Union[SnmpAuthAlgorithm, str]] = None, community: Optional[str] = None, - privacy_algorithm: Optional[SnmpPrivacyAlgorithm] = None, + privacy_algorithm: Optional[Union[SnmpPrivacyAlgorithm, str]] = None, privacy_password: Optional[str] = None, public_key: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies an existing credential. Arguments: @@ -454,18 +446,15 @@ def modify_credential( privacy_algorithm: The privacy algorithm for SNMP privacy_password: The SNMP privacy password public_key: PGP public key in *armor* plain text format - - Returns: - The response. See :py:meth:`send_command` for details. """ if not credential_id: raise RequiredArgument( - function=self.modify_credential.__name__, + function=cls.modify_credential.__name__, argument="credential_id", ) cmd = XmlCommand("modify_credential") - cmd.set_attribute("credential_id", credential_id) + cmd.set_attribute("credential_id", str(credential_id)) if comment: cmd.add_element("comment", comment) @@ -480,14 +469,14 @@ def modify_credential( cmd.add_element("certificate", certificate) if key_phrase and private_key: - _xmlkey = cmd.add_element("key") - _xmlkey.add_element("phrase", key_phrase) - _xmlkey.add_element("private", private_key) + xml_key = cmd.add_element("key") + xml_key.add_element("phrase", key_phrase) + xml_key.add_element("private", private_key) elif (not key_phrase and private_key) or ( key_phrase and not private_key ): raise RequiredArgument( - function=self.modify_credential.__name__, + function=cls.modify_credential.__name__, argument="key_phrase and private_key", ) @@ -499,34 +488,26 @@ def modify_credential( if auth_algorithm: if not isinstance(auth_algorithm, SnmpAuthAlgorithm): - raise InvalidArgumentType( - function=self.modify_credential.__name__, - argument="auth_algorithm", - arg_type=SnmpAuthAlgorithm.__name__, - ) + auth_algorithm = SnmpAuthAlgorithm(auth_algorithm) + cmd.add_element("auth_algorithm", auth_algorithm.value) if community: cmd.add_element("community", community) if privacy_algorithm is not None or privacy_password is not None: - _xmlprivacy = cmd.add_element("privacy") + xml_privacy = cmd.add_element("privacy") if privacy_algorithm is not None: if not isinstance(privacy_algorithm, SnmpPrivacyAlgorithm): - raise InvalidArgumentType( - function=self.modify_credential.__name__, - argument="privacy_algorithm", - arg_type=SnmpPrivacyAlgorithm.__name__, - ) - - _xmlprivacy.add_element("algorithm", privacy_algorithm.value) + privacy_algorithm = SnmpPrivacyAlgorithm(privacy_algorithm) + xml_privacy.add_element("algorithm", privacy_algorithm.value) if privacy_password is not None: - _xmlprivacy.add_element("password", privacy_password) + xml_privacy.add_element("password", privacy_password) if public_key: - _xmlkey = cmd.add_element("key") - _xmlkey.add_element("public", public_key) + xml_key = cmd.add_element("key") + xml_key.add_element("public", public_key) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_cves.py b/gvm/protocols/gmp/requests/v224/_cves.py new file mode 100644 index 000000000..85059bcb7 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_cves.py @@ -0,0 +1,68 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class Cves: + + @staticmethod + def get_cves( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> Request: + """Request a list of CVEs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", "CVE") + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd + + @classmethod + def get_cve(cls, cve_id: str) -> Request: + """Request a single CVE + + Args: + cve_id: ID of an existing CVE + """ + if not cve_id: + raise RequiredArgument( + function=cls.get_cve.__name__, argument="cve_id" + ) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", cve_id) + + cmd.set_attribute("type", "CVE") + + # for single entity always request all details + cmd.set_attribute("details", "1") + + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_dfn_cert_advisories.py b/gvm/protocols/gmp/requests/v224/_dfn_cert_advisories.py new file mode 100644 index 000000000..3f156ad0e --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_dfn_cert_advisories.py @@ -0,0 +1,68 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class DfnCertAdvisories: + + @staticmethod + def get_dfn_cert_advisories( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> Request: + """Request a list of DFN-CERT Advisories + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", "DFN_CERT_ADV") + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd + + @classmethod + def get_dfn_cert_advisory(cls, cert_id: EntityID) -> Request: + """Request a single DFN-CERT Advisory + + Args: + cert_id: ID of an existing DFN-CERT Advisory + """ + if not cert_id: + raise RequiredArgument( + function=cls.get_dfn_cert_advisory.__name__, argument="cert_id" + ) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", str(cert_id)) + + cmd.set_attribute("type", "DFN_CERT_ADV") + + # for single entity always request all details + cmd.set_attribute("details", "1") + + return cmd diff --git a/gvm/protocols/gmpv208/entities/entities.py b/gvm/protocols/gmp/requests/v224/_entity_type.py similarity index 96% rename from gvm/protocols/gmpv208/entities/entities.py rename to gvm/protocols/gmp/requests/v224/_entity_type.py index 865964844..fed96ad0b 100644 --- a/gvm/protocols/gmpv208/entities/entities.py +++ b/gvm/protocols/gmp/requests/v224/_entity_type.py @@ -1,7 +1,6 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# from typing import Optional diff --git a/gvm/protocols/gmp/requests/v224/_feed.py b/gvm/protocols/gmp/requests/v224/_feed.py new file mode 100644 index 000000000..4e33a7135 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_feed.py @@ -0,0 +1,46 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Union + +from gvm._enum import Enum +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.xml import XmlCommand + + +class FeedType(Enum): + """Enum for feed types""" + + NVT = "NVT" + CERT = "CERT" + SCAP = "SCAP" + GVMD_DATA = "GVMD_DATA" + + +class Feed: + @staticmethod + def get_feeds() -> Request: + """Request the list of feeds""" + return XmlCommand("get_feeds") + + @classmethod + def get_feed(cls, feed_type: Union[FeedType, str]) -> Request: + """Request a single feed + + Arguments: + feed_type: Type of single feed to get: NVT, CERT or SCAP + """ + if not feed_type: + raise RequiredArgument( + function=cls.get_feed.__name__, argument="feed_type" + ) + + if not isinstance(feed_type, FeedType): + feed_type = FeedType(feed_type) + + cmd = XmlCommand("get_feeds") + cmd.set_attribute("type", feed_type.value) + + return cmd diff --git a/gvm/protocols/gmpv208/entities/filter.py b/gvm/protocols/gmp/requests/v224/_filters.py similarity index 65% rename from gvm/protocols/gmpv208/entities/filter.py rename to gvm/protocols/gmp/requests/v224/_filters.py index 0402d06dd..8b3049daf 100644 --- a/gvm/protocols/gmpv208/entities/filter.py +++ b/gvm/protocols/gmp/requests/v224/_filters.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class FilterType(Enum): """Enum for filter types""" @@ -47,7 +49,7 @@ def from_string( ) -> Optional["FilterType"]: """Convert a filter type string to an actual FilterType instance - Arguments: + Args: filter_type (str): Filter type string to convert to a FilterType """ if filter_type == "vuln": @@ -65,47 +67,43 @@ def from_string( return super().from_string(filter_type) -class FiltersMixin: - def clone_filter(self, filter_id: str) -> Any: - """Clone an existing filter - - Arguments: - filter_id: UUID of an existing filter to clone from +class Filters: + @classmethod + def clone_filter(cls, filter_id: EntityID) -> Request: + """Clone a filter - Returns: - The response. See :py:meth:`send_command` for details. + Args: + filter_id: ID of the filter to clone """ if not filter_id: raise RequiredArgument( - function=self.clone_filter.__name__, argument="filter_id" + function=cls.clone_filter.__name__, argument="filter_id" ) cmd = XmlCommand("create_filter") - cmd.add_element("copy", filter_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(filter_id)) + return cmd + @classmethod def create_filter( - self, + cls, name: str, *, filter_type: Optional[FilterType] = None, comment: Optional[str] = None, term: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new filter - Arguments: + Args: name: Name of the new filter filter_type: Filter for entity type comment: Comment for the filter term: Filter term e.g. 'name=foo' - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_filter.__name__, argument="name" + function=cls.create_filter.__name__, argument="name" ) cmd = XmlCommand("create_filter") @@ -119,58 +117,52 @@ def create_filter( if filter_type: if not isinstance(filter_type, FilterType): - raise InvalidArgumentType( - function=self.create_filter.__name__, - argument="filter_type", - arg_type=FilterType.__name__, - ) + filter_type = FilterType(filter_type) cmd.add_element("type", filter_type.value) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_filter( - self, filter_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, filter_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing filter - Arguments: + Args: filter_id: UUID of the filter to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not filter_id: raise RequiredArgument( - function=self.delete_filter.__name__, argument="filter_id" + function=cls.delete_filter.__name__, argument="filter_id" ) cmd = XmlCommand("delete_filter") - cmd.set_attribute("filter_id", filter_id) + cmd.set_attribute("filter_id", str(filter_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_filters( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, alerts: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of filters - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan filters instead alerts: Whether to include list of alerts that use the filter. - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_filters") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -178,62 +170,58 @@ def get_filters( if alerts is not None: cmd.set_attribute("alerts", to_bool(alerts)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_filter( - self, filter_id: str, *, alerts: Optional[bool] = None - ) -> Any: + cls, filter_id: EntityID, *, alerts: Optional[bool] = None + ) -> Request: """Request a single filter - Arguments: + Args: filter_id: UUID of an existing filter alerts: Whether to include list of alerts that use the filter. - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_filters") if not filter_id: raise RequiredArgument( - function=self.get_filter.__name__, argument="filter_id" + function=cls.get_filter.__name__, argument="filter_id" ) - cmd.set_attribute("filter_id", filter_id) + cmd.set_attribute("filter_id", str(filter_id)) if alerts is not None: cmd.set_attribute("alerts", to_bool(alerts)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_filter( - self, - filter_id: str, + cls, + filter_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, term: Optional[str] = None, filter_type: Optional[FilterType] = None, - ) -> Any: + ) -> Request: """Modifies an existing filter. - Arguments: + Args: filter_id: UUID of the filter to be modified comment: Comment on filter. name: Name of filter. term: Filter term. filter_type: Resource type filter applies to. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not filter_id: raise RequiredArgument( - function=self.modify_filter.__name__, argument="filter_id" + function=cls.modify_filter.__name__, argument="filter_id" ) cmd = XmlCommand("modify_filter") - cmd.set_attribute("filter_id", filter_id) + cmd.set_attribute("filter_id", str(filter_id)) if comment: cmd.add_element("comment", comment) @@ -246,11 +234,8 @@ def modify_filter( if filter_type: if not isinstance(filter_type, FilterType): - raise InvalidArgumentType( - function=self.modify_filter.__name__, - argument="filter_type", - arg_type=FilterType.__name__, - ) + filter_type = FilterType(filter_type) + cmd.add_element("type", filter_type.value) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/groups.py b/gvm/protocols/gmp/requests/v224/_groups.py similarity index 57% rename from gvm/protocols/gmpv208/entities/groups.py rename to gvm/protocols/gmp/requests/v224/_groups.py index c0978445b..3e0a23afd 100644 --- a/gvm/protocols/gmpv208/entities/groups.py +++ b/gvm/protocols/gmp/requests/v224/_groups.py @@ -1,57 +1,56 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, List, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool, to_comma_list +from gvm.protocols.core import Request +from gvm.utils import to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID + -class GroupsMixin: - def clone_group(self, group_id: str) -> Any: +class Groups: + @classmethod + def clone_group(cls, group_id: EntityID) -> Request: """Clone an existing group - Arguments: + Args: group_id: UUID of an existing group to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not group_id: raise RequiredArgument( - function=self.clone_group.__name__, argument="group_id" + function=cls.clone_group.__name__, argument="group_id" ) cmd = XmlCommand("create_group") - cmd.add_element("copy", group_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(group_id)) + + return cmd + @classmethod def create_group( - self, + cls, name: str, *, comment: Optional[str] = None, special: Optional[bool] = False, - users: Optional[List[str]] = None, - ) -> Any: + users: Optional[list[str]] = None, + ) -> Request: """Create a new group - Arguments: + Args: name: Name of the new group comment: Comment for the group special: Create permission giving members full access to each other's entities users: List of user names to be in the group - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_group.__name__, argument="name" + function=cls.create_group.__name__, argument="name" ) cmd = XmlCommand("create_group") @@ -61,105 +60,99 @@ def create_group( cmd.add_element("comment", comment) if special: - _xmlspecial = cmd.add_element("specials") - _xmlspecial.add_element("full") + xml_special = cmd.add_element("specials") + xml_special.add_element("full") if users: cmd.add_element("users", to_comma_list(users)) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_group( - self, group_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, group_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing group - Arguments: + Args: group_id: UUID of the group to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not group_id: raise RequiredArgument( - function=self.delete_group.__name__, argument="group_id" + function=cls.delete_group.__name__, argument="group_id" ) cmd = XmlCommand("delete_group") - cmd.set_attribute("group_id", group_id) + cmd.set_attribute("group_id", str(group_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_groups( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of groups - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan groups instead - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_groups") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd - def get_group(self, group_id: str) -> Any: + @classmethod + def get_group(cls, group_id: EntityID) -> Request: """Request a single group - Arguments: + Args: group_id: UUID of an existing group - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_groups") if not group_id: raise RequiredArgument( - function=self.get_group.__name__, argument="group_id" + function=cls.get_group.__name__, argument="group_id" ) - cmd.set_attribute("group_id", group_id) - return self._send_xml_command(cmd) + cmd.set_attribute("group_id", str(group_id)) + return cmd + @classmethod def modify_group( - self, - group_id: str, + cls, + group_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, - users: Optional[List[str]] = None, - ) -> Any: + users: Optional[list[str]] = None, + ) -> Request: """Modifies an existing group. - Arguments: + Args: group_id: UUID of group to modify. comment: Comment on group. name: Name of group. users: List of user names to be in the group - - Returns: - The response. See :py:meth:`send_command` for details. """ if not group_id: raise RequiredArgument( - function=self.modify_group.__name__, argument="group_id" + function=cls.modify_group.__name__, argument="group_id" ) cmd = XmlCommand("modify_group") - cmd.set_attribute("group_id", group_id) + cmd.set_attribute("group_id", str(group_id)) if comment: cmd.add_element("comment", comment) @@ -170,4 +163,4 @@ def modify_group( if users: cmd.add_element("users", to_comma_list(users)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/system/help.py b/gvm/protocols/gmp/requests/v224/_help.py similarity index 58% rename from gvm/protocols/gmpv208/system/help.py rename to gvm/protocols/gmp/requests/v224/_help.py index 233e34552..1bbffd624 100644 --- a/gvm/protocols/gmpv208/system/help.py +++ b/gvm/protocols/gmp/requests/v224/_help.py @@ -1,12 +1,11 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType +from gvm.protocols.core import Request from gvm.xml import XmlCommand @@ -19,22 +18,19 @@ class HelpFormat(Enum): XML = "xml" -class HelpMixin: +class Help: + @staticmethod def help( - self, *, - help_format: Optional[HelpFormat] = None, + help_format: Optional[Union[HelpFormat, str]] = None, brief: Optional[bool] = None, - ) -> Any: + ) -> Request: """Get the help text Arguments: help_format: Format of of the help: "html", "rnc", "text" or "xml brief: If True help is brief - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("help") @@ -46,12 +42,8 @@ def help( if help_format: if not isinstance(help_format, HelpFormat): - raise InvalidArgumentType( - function=self.help.__name__, - argument="feed_type", - arg_type=HelpFormat.__name__, - ) + help_format = HelpFormat(help_format) cmd.set_attribute("format", help_format.value) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/hosts.py b/gvm/protocols/gmp/requests/v224/_hosts.py similarity index 60% rename from gvm/protocols/gmpv208/entities/hosts.py rename to gvm/protocols/gmp/requests/v224/_hosts.py index 0aa7171dc..2e971bd87 100644 --- a/gvm/protocols/gmpv208/entities/hosts.py +++ b/gvm/protocols/gmp/requests/v224/_hosts.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm._enum import Enum from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class HostsOrdering(Enum): """Enum for host ordering during scans""" @@ -19,20 +21,21 @@ class HostsOrdering(Enum): REVERSE = "reverse" -class HostsMixin: - def create_host(self, name: str, *, comment: Optional[str] = None) -> Any: +class Hosts: + + @classmethod + def create_host( + cls, name: str, *, comment: Optional[str] = None + ) -> Request: """Create a new host host - Arguments: + Args: name: Name for the new host host comment: Comment for the new host host - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_host.__name__, argument="name" + function=cls.create_host.__name__, argument="name" ) cmd = XmlCommand("create_asset") @@ -43,101 +46,97 @@ def create_host(self, name: str, *, comment: Optional[str] = None) -> Any: if comment: host.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd - def delete_host(self, host_id: str) -> Any: + @classmethod + def delete_host(cls, host_id: EntityID) -> Request: """Deletes an existing host - Arguments: + Args: host_id: UUID of the single host to delete. """ if not host_id: raise RequiredArgument( - function=self.delete_host.__name__, + function=cls.delete_host.__name__, argument="host_id", ) cmd = XmlCommand("delete_asset") - cmd.set_attribute("asset_id", host_id) + cmd.set_attribute("asset_id", str(host_id)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_hosts( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of hosts - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query details: Whether to include additional information (e.g. tags) - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_assets") cmd.set_attribute("type", "host") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd - def get_host(self, host_id: str, *, details: Optional[bool] = None) -> Any: + @classmethod + def get_host( + cls, host_id: EntityID, *, details: Optional[bool] = None + ) -> Request: """Request a single host Arguments: host_id: UUID of an existing host details: Whether to include additional information (e.g. tags) - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_assets") if not host_id: raise RequiredArgument( - function=self.get_host.__name__, argument="host_id" + function=cls.get_host.__name__, argument="host_id" ) - cmd.set_attribute("asset_id", host_id) + cmd.set_attribute("asset_id", str(host_id)) cmd.set_attribute("type", "host") if details is not None: cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_host( - self, host_id: str, *, comment: Optional[str] = None - ) -> Any: + cls, host_id: EntityID, *, comment: Optional[str] = None + ) -> Request: """Modifies an existing host. - Arguments: + Args: host_id: UUID of the host to be modified. comment: Comment for the host. Not passing a comment arguments clears the comment for this host. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not host_id: raise RequiredArgument( - function=self.modify_host.__name__, argument="host_id" + function=cls.modify_host.__name__, argument="host_id" ) cmd = XmlCommand("modify_asset") - cmd.set_attribute("asset_id", host_id) + cmd.set_attribute("asset_id", str(host_id)) if not comment: comment = "" cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_notes.py b/gvm/protocols/gmp/requests/v224/_notes.py new file mode 100644 index 000000000..846daaa67 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_notes.py @@ -0,0 +1,230 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import check_port, to_bool, to_comma_list +from gvm.xml import XmlCommand + +from .._entity_id import EntityID +from ._severity import Severity + + +class Notes: + @classmethod + def create_note( + cls, + text: str, + nvt_oid: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> Request: + """Create a new note + + Args: + text: Text of the new note + nvt_id: OID of the nvt to which note applies + days_active: Days note will be active. -1 on + always, 0 off + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: UUID of a result to which note applies + severity: Severity to which note applies + task_id: UUID of task to which note applies + """ + if not text: + raise RequiredArgument( + function=cls.create_note.__name__, argument="text" + ) + + if not nvt_oid: + raise RequiredArgument( + function=cls.create_note.__name__, argument="nvt_oid" + ) + + cmd = XmlCommand("create_note") + cmd.add_element("text", text) + cmd.add_element("nvt", attrs={"oid": nvt_oid}) + + if days_active is not None: + cmd.add_element("active", str(days_active)) + + if hosts: + cmd.add_element("hosts", to_comma_list(hosts)) + + if port: + if check_port(port): + cmd.add_element("port", port) + else: + raise InvalidArgument( + function=cls.create_note.__name__, argument="port" + ) + + if result_id: + cmd.add_element("result", attrs={"id": str(result_id)}) + + if severity is not None: + cmd.add_element("severity", str(severity)) + + if task_id: + cmd.add_element("task", attrs={"id": str(task_id)}) + + return cmd + + @classmethod + def modify_note( + cls, + note_id: EntityID, + text: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> Request: + """Modify a note + + Args: + note_id: The UUID of the note to modify + text: Text of the note + days_active: Days note will be active. -1 on always, 0 off + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: UUID of a result to which note applies + severity: Severity to which note applies + task_id: UUID of task to which note applies + """ + if not note_id: + raise RequiredArgument( + function=cls.modify_note.__name__, argument="note_id" + ) + + if not text: + raise RequiredArgument( + function=cls.modify_note.__name__, argument="text" + ) + + cmd = XmlCommand("modify_note") + cmd.set_attribute("note_id", str(note_id)) + cmd.add_element("text", text) + + if days_active is not None: + cmd.add_element("active", str(days_active)) + + if hosts: + cmd.add_element("hosts", to_comma_list(hosts)) + + if port: + if check_port(port): + cmd.add_element("port", port) + else: + raise InvalidArgument( + function=cls.modify_note.__name__, argument="port" + ) + + if result_id: + cmd.add_element("result", attrs={"id": str(result_id)}) + + if severity is not None: + cmd.add_element("severity", str(severity)) + + if task_id: + cmd.add_element("task", attrs={"id": str(task_id)}) + + return cmd + + @classmethod + def clone_note(cls, note_id: EntityID) -> Request: + """Clone an existing note + + Args: + note_id: UUID of an existing note to clone from + """ + if not note_id: + raise RequiredArgument( + function=cls.clone_note.__name__, argument="note_id" + ) + + cmd = XmlCommand("create_note") + cmd.add_element("copy", str(note_id)) + return cmd + + @classmethod + def delete_note( + cls, note_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing note + + Args: + note_id: UUID of the note to be deleted. + ultimate: Whether to remove entirely or to the trashcan. + """ + if not note_id: + raise RequiredArgument( + function=cls.delete_note.__name__, argument="note_id" + ) + + cmd = XmlCommand("delete_note") + cmd.set_attribute("note_id", str(note_id)) + cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd + + @classmethod + def get_notes( + cls, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + details: Optional[bool] = None, + result: Optional[bool] = None, + ) -> Request: + """Request a list of notes + + Args: + filter_string: Filter notes by a string + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + details: Add info about connected results and tasks + result: Return the details of possible connected results. + """ + cmd = XmlCommand("get_notes") + cmd.add_filter(filter_string, filter_id) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + if result is not None: + cmd.set_attribute("result", to_bool(result)) + + return cmd + + @classmethod + def get_note(cls, note_id: EntityID) -> Request: + """Request a single note + + Arguments: + note_id: UUID of an existing note + """ + if not note_id: + raise RequiredArgument( + function=cls.get_note.__name__, argument="note_id" + ) + + cmd = XmlCommand("get_notes") + cmd.set_attribute("note_id", str(note_id)) + + # for single entity always request all details + cmd.set_attribute("details", "1") + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_nvts.py b/gvm/protocols/gmp/requests/v224/_nvts.py new file mode 100644 index 000000000..8337271a8 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_nvts.py @@ -0,0 +1,253 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class Nvts: + + @staticmethod + def get_nvt_families(*, sort_order: Optional[str] = None) -> Request: + """Request a list of nvt families + + Args: + sort_order: Sort order + """ + cmd = XmlCommand("get_nvt_families") + + if sort_order: + cmd.set_attribute("sort_order", sort_order) + + return cmd + + @staticmethod + def get_scan_config_nvts( + *, + details: Optional[bool] = None, + preferences: Optional[bool] = None, + preference_count: Optional[bool] = None, + timeout: Optional[bool] = None, + config_id: Optional[EntityID] = None, + preferences_config_id: Optional[EntityID] = None, + family: Optional[str] = None, + sort_order: Optional[str] = None, + sort_field: Optional[str] = None, + ) -> Request: + """Request a list of nvts + + Args: + details: Whether to include full details + preferences: Whether to include nvt preferences + preference_count: Whether to include preference count + timeout: Whether to include the special timeout preference + config_id: UUID of scan config to which to limit the NVT listing + preferences_config_id: UUID of scan config to use for preference + values + family: Family to which to limit NVT listing + sort_order: Sort order + sort_field: Sort field + """ + cmd = XmlCommand("get_nvts") + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + if preferences is not None: + cmd.set_attribute("preferences", to_bool(preferences)) + + if preference_count is not None: + cmd.set_attribute("preference_count", to_bool(preference_count)) + + if timeout is not None: + cmd.set_attribute("timeout", to_bool(timeout)) + + if config_id: + cmd.set_attribute("config_id", str(config_id)) + + if preferences_config_id: + cmd.set_attribute( + "preferences_config_id", str(preferences_config_id) + ) + + if family: + cmd.set_attribute("family", family) + + if sort_order: + cmd.set_attribute("sort_order", sort_order) + + if sort_field: + cmd.set_attribute("sort_field", sort_field) + + return cmd + + @classmethod + def get_scan_config_nvt(cls, nvt_oid: str) -> Request: + """Request a single nvt + + Args: + nvt_oid: OID of an existing nvt + """ + cmd = XmlCommand("get_nvts") + + if not nvt_oid: + raise RequiredArgument( + function=cls.get_scan_config_nvt.__name__, argument="nvt_oid" + ) + + cmd.set_attribute("nvt_oid", nvt_oid) + + # for single entity always request all details + cmd.set_attribute("details", "1") + cmd.set_attribute("preferences", "1") + cmd.set_attribute("preference_count", "1") + + return cmd + + @classmethod + def get_nvts( + cls, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + extended: Optional[bool] = None, + preferences: Optional[bool] = None, + preference_count: Optional[bool] = None, + timeout: Optional[bool] = None, + config_id: Optional[str] = None, + preferences_config_id: Optional[str] = None, + family: Optional[str] = None, + sort_order: Optional[str] = None, + sort_field: Optional[str] = None, + ) -> Request: + """Request a list of NVTs + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + extended: Whether to receive extended NVT information + (calls get_nvts, instead of get_info) + preferences: Whether to include NVT preferences (only for extended) + preference_count: Whether to include preference count (only for extended) + timeout: Whether to include the special timeout preference (only for extended) + config_id: UUID of scan config to which to limit the NVT listing (only for extended) + preferences_config_id: UUID of scan config to use for preference + values (only for extended) + family: Family to which to limit NVT listing (only for extended) + sort_order: Sort order (only for extended) + sort_field: Sort field (only for extended) + """ + if extended: + return cls.get_scan_config_nvts( + details=details, + preferences=preferences, + preference_count=preference_count, + timeout=timeout, + config_id=config_id, + preferences_config_id=preferences_config_id, + family=family, + sort_order=sort_order, + sort_field=sort_field, + ) + + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", "NVT") + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd + + @classmethod + def get_nvt( + cls, nvt_id: str, *, extended: Optional[bool] = None + ) -> Request: + """Request a single NVT + + Args: + nvt_id: ID of an existing NVT + extended: Whether to receive extended NVT information + (calls get_nvts, instead of get_info) + """ + if not nvt_id: + raise RequiredArgument( + function=cls.get_nvt.__name__, argument="nvt_id" + ) + + if extended: + return cls.get_scan_config_nvt(nvt_id) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", nvt_id) + + cmd.set_attribute("type", "NVT") + + # for single entity always request all details + cmd.set_attribute("details", "1") + return cmd + + @staticmethod + def get_nvt_preferences( + *, + nvt_oid: Optional[str] = None, + ) -> Request: + """Request a list of preferences + + The preference element includes just the + name and value, with the NVT and type built into the name. + + Args: + nvt_oid: OID of nvt + """ + cmd = XmlCommand("get_preferences") + + if nvt_oid: + cmd.set_attribute("nvt_oid", nvt_oid) + + return cmd + + @classmethod + def get_nvt_preference( + cls, + name: str, + *, + nvt_oid: Optional[str] = None, + ) -> Request: + """Request a nvt preference + + Args: + name: name of a particular preference + nvt_oid: OID of nvt + config_id: UUID of scan config of which to show preference values + """ + cmd = XmlCommand("get_preferences") + + if not name: + raise RequiredArgument( + function=cls.get_nvt_preference.__name__, argument="name" + ) + + cmd.set_attribute("preference", name) + + if nvt_oid: + cmd.set_attribute("nvt_oid", nvt_oid) + + return cmd diff --git a/gvm/protocols/gmpv208/entities/operating_systems.py b/gvm/protocols/gmp/requests/v224/_operating_systems.py similarity index 57% rename from gvm/protocols/gmpv208/entities/operating_systems.py rename to gvm/protocols/gmp/requests/v224/_operating_systems.py index 9c866cba0..5ac3d69d0 100644 --- a/gvm/protocols/gmpv208/entities/operating_systems.py +++ b/gvm/protocols/gmp/requests/v224/_operating_systems.py @@ -1,117 +1,113 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + -class OperatingSystemsMixin: +class OperatingSystems: + + @classmethod def delete_operating_system( - self, - operating_system_id: str, - ) -> Any: - """Deletes an existing operating_system + cls, + operating_system_id: EntityID, + ) -> Request: + """Deletes an existing operating system - Arguments: + Args: operating_system_id: UUID of the single operating_system to delete. - """ if not operating_system_id: raise RequiredArgument( - function=self.delete_operating_system.__name__, + function=cls.delete_operating_system.__name__, argument="operating_system_id", ) cmd = XmlCommand("delete_asset") - cmd.set_attribute("asset_id", operating_system_id) + cmd.set_attribute("asset_id", str(operating_system_id)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_operating_systems( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, details: Optional[bool] = None, - ) -> Any: - """Request a list of operating_systems + ) -> Request: + """Request a list of operating systems - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query details: Whether to include additional information (e.g. tags) - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_assets") cmd.set_attribute("type", "os") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_operating_system( - self, operating_system_id: str, *, details: Optional[bool] = None - ) -> Any: - """Request a single operating_system + cls, operating_system_id: EntityID, *, details: Optional[bool] = None + ) -> Request: + """Request a single operating system - Arguments: + Args: operating_system_id: UUID of an existing operating_system details: Whether to include additional information (e.g. tags) - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_assets") if not operating_system_id: raise RequiredArgument( - function=self.get_operating_system.__name__, + function=cls.get_operating_system.__name__, argument="operating_system_id", ) - cmd.set_attribute("asset_id", operating_system_id) + cmd.set_attribute("asset_id", str(operating_system_id)) cmd.set_attribute("type", "os") if details is not None: cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_operating_system( - self, operating_system_id: str, *, comment: Optional[str] = None - ) -> Any: + cls, operating_system_id: EntityID, *, comment: Optional[str] = None + ) -> Request: """Modifies an existing operating system. - Arguments: + Args: operating_system_id: UUID of the operating_system to be modified. comment: Comment for the operating_system. Not passing a comment arguments clears the comment for this operating system. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not operating_system_id: raise RequiredArgument( - function=self.modify_operating_system.__name__, + function=cls.modify_operating_system.__name__, argument="operating_system_id", ) cmd = XmlCommand("modify_asset") - cmd.set_attribute("asset_id", operating_system_id) + cmd.set_attribute("asset_id", str(operating_system_id)) if not comment: comment = "" cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/overrides.py b/gvm/protocols/gmp/requests/v224/_overrides.py similarity index 50% rename from gvm/protocols/gmpv208/entities/overrides.py rename to gvm/protocols/gmp/requests/v224/_overrides.py index 15c667485..9be5ee25d 100644 --- a/gvm/protocols/gmpv208/entities/overrides.py +++ b/gvm/protocols/gmp/requests/v224/_overrides.py @@ -1,35 +1,37 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, List, Optional +from typing import Optional -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.severity import Severity, SeverityLevel -from gvm.utils import add_filter, check_port, to_bool, to_comma_list +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import check_port, to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._severity import Severity + -class OverridesMixin: +class Overrides: + + @classmethod def create_override( - self, + cls, text: str, nvt_oid: str, *, days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, + hosts: Optional[list[str]] = None, port: Optional[str] = None, - result_id: Optional[str] = None, + result_id: Optional[EntityID] = None, severity: Optional[Severity] = None, new_severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Optional[SeverityLevel] = None, - new_threat: Optional[SeverityLevel] = None, - ) -> Any: + task_id: Optional[EntityID] = None, + ) -> Request: """Create a new override - Arguments: + Args: text: Text of the new override nvt_id: OID of the nvt to which override applies days_active: Days override will be active. -1 on always, 0 off @@ -40,22 +42,15 @@ def create_override( severity: Severity to which override applies new_severity: New severity for result task_id: UUID of task to which override applies - threat: Severity level to which override applies. Will be converted - to severity. - new_threat: New severity level for results. Will be converted to - new_severity. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not text: raise RequiredArgument( - function=self.create_override.__name__, argument="text" + function=cls.create_override.__name__, argument="text" ) if not nvt_oid: raise RequiredArgument( - function=self.create_override.__name__, argument="nvt_oid" + function=cls.create_override.__name__, argument="nvt_oid" ) cmd = XmlCommand("create_override") @@ -70,10 +65,10 @@ def create_override( if port: if check_port(port): - cmd.add_element("port", str(port)) + cmd.add_element("port", port) else: raise InvalidArgument( - function=self.create_override.__name__, argument="port" + function=cls.create_override.__name__, argument="port" ) if result_id: @@ -88,88 +83,133 @@ def create_override( if task_id: cmd.add_element("task", attrs={"id": task_id}) - if threat is not None: - if not isinstance(threat, SeverityLevel): - raise InvalidArgumentType( - function=self.create_override.__name__, - argument="threat", - arg_type=SeverityLevel.__name__, - ) + return cmd - cmd.add_element("threat", threat.value) + @classmethod + def modify_override( + cls, + override_id: EntityID, + text: str, + *, + days_active: Optional[int] = None, + hosts: Optional[list[str]] = None, + port: Optional[str] = None, + result_id: Optional[EntityID] = None, + severity: Optional[Severity] = None, + new_severity: Optional[Severity] = None, + task_id: Optional[EntityID] = None, + ) -> Request: + """Modify an existing override. - if new_threat is not None: - if not isinstance(new_threat, SeverityLevel): - raise InvalidArgumentType( - function=self.create_override.__name__, - argument="new_threat", - arg_type=SeverityLevel.__name__, + Args: + override_id: UUID of override to modify. + text: The text of the override. + days_active: Days override will be active. -1 on always, + 0 off. + hosts: A list of host addresses + port: Port to which the override applies, needs to be a string + in the form {number}/{protocol} + result_id: Result to which override applies. + severity: Severity to which override applies. + new_severity: New severity score for result. + task_id: Task to which override applies. + """ + if not override_id: + raise RequiredArgument( + function=cls.modify_override.__name__, argument="override_id" + ) + + if not text: + raise RequiredArgument( + function=cls.modify_override.__name__, argument="text" + ) + + cmd = XmlCommand("modify_override") + cmd.set_attribute("override_id", str(override_id)) + cmd.add_element("text", text) + + if days_active is not None: + cmd.add_element("active", str(days_active)) + + if hosts: + cmd.add_element("hosts", to_comma_list(hosts)) + + if port: + if check_port(port): + cmd.add_element("port", str(port)) + else: + raise InvalidArgument( + function=cls.modify_override.__name__, argument="port" ) - cmd.add_element("new_threat", new_threat.value) + if result_id: + cmd.add_element("result", attrs={"id": str(result_id)}) + + if severity is not None: + cmd.add_element("severity", str(severity)) - return self._send_xml_command(cmd) + if new_severity is not None: + cmd.add_element("new_severity", str(new_severity)) - def clone_override(self, override_id: str) -> Any: + if task_id: + cmd.add_element("task", attrs={"id": str(task_id)}) + + return cmd + + @classmethod + def clone_override(cls, override_id: EntityID) -> Request: """Clone an existing override - Arguments: + Args: override_id: UUID of an existing override to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not override_id: raise RequiredArgument( - function=self.clone_override.__name__, argument="override_id" + function=cls.clone_override.__name__, argument="override_id" ) cmd = XmlCommand("create_override") - cmd.add_element("copy", override_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(override_id)) + return cmd + @classmethod def delete_override( - self, override_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing override + cls, override_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing override - Arguments: - override_id: UUID of the override to be deleted. + Args: + override_id: UUID of an existing override to delete ultimate: Whether to remove entirely, or to the trashcan. """ if not override_id: raise RequiredArgument( - function=self.delete_override.__name__, argument="override_id" + function=cls.delete_override.__name__, argument="override_id" ) cmd = XmlCommand("delete_override") - cmd.set_attribute("override_id", override_id) + cmd.set_attribute("override_id", str(override_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd - return self._send_xml_command(cmd) - + @staticmethod def get_overrides( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, details: Optional[bool] = None, result: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of overrides - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query details: Whether to include full details result: Whether to include results using the override - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_overrides") - - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) @@ -177,123 +217,24 @@ def get_overrides( if result is not None: cmd.set_attribute("result", to_bool(result)) - return self._send_xml_command(cmd) + return cmd - def get_override(self, override_id: str) -> Any: + @classmethod + def get_override(cls, override_id: EntityID) -> Request: """Request a single override - Arguments: + Args: override_id: UUID of an existing override - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_overrides") if not override_id: raise RequiredArgument( - function=self.get_override.__name__, argument="override_id" + function=cls.get_override.__name__, argument="override_id" ) - cmd.set_attribute("override_id", override_id) + cmd.set_attribute("override_id", str(override_id)) # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) - - def modify_override( - self, - override_id: str, - text: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[str] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - new_severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Optional[SeverityLevel] = None, - new_threat: Optional[SeverityLevel] = None, - ) -> Any: - """Modifies an existing override. - - Arguments: - override_id: UUID of override to modify. - text: The text of the override. - days_active: Days override will be active. -1 on always, - 0 off. - hosts: A list of host addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: Result to which override applies. - severity: Severity to which override applies. - new_severity: New severity score for result. - task_id: Task to which override applies. - threat: Threat level to which override applies. - Will be converted to severity. - new_threat: New threat level for results. Will be converted to - new_severity. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not override_id: - raise RequiredArgument( - function=self.modify_override.__name__, argument="override_id" - ) - if not text: - raise RequiredArgument( - function=self.modify_override.__name__, argument="text" - ) - - cmd = XmlCommand("modify_override") - cmd.set_attribute("override_id", override_id) - cmd.add_element("text", text) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.modify_override.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if new_severity is not None: - cmd.add_element("new_severity", str(new_severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - if not isinstance(threat, SeverityLevel): - raise InvalidArgumentType( - function=self.modify_override.__name__, - argument="threat", - arg_type=SeverityLevel.__name__, - ) - cmd.add_element("threat", threat.value) - - if new_threat is not None: - if not isinstance(new_threat, SeverityLevel): - raise InvalidArgumentType( - function=self.modify_override.__name__, - argument="new_threat", - arg_type=SeverityLevel.__name__, - ) - - cmd.add_element("new_threat", new_threat.value) - - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/permissions.py b/gvm/protocols/gmp/requests/v224/_permissions.py similarity index 53% rename from gvm/protocols/gmpv208/entities/permissions.py rename to gvm/protocols/gmp/requests/v224/_permissions.py index f2ce51b37..b1a31fd5b 100644 --- a/gvm/protocols/gmpv208/entities/permissions.py +++ b/gvm/protocols/gmp/requests/v224/_permissions.py @@ -1,16 +1,18 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.utils import add_filter, to_bool +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._entity_type import EntityType + class PermissionSubjectType(Enum): """Enum for permission subject type""" @@ -20,39 +22,39 @@ class PermissionSubjectType(Enum): ROLE = "role" -class PermissionsMixin: - def clone_permission(self, permission_id: str) -> Any: +class Permissions: + + @classmethod + def clone_permission(cls, permission_id: EntityID) -> Request: """Clone an existing permission - Arguments: + Args: permission_id: UUID of an existing permission to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not permission_id: raise RequiredArgument( - function=self.clone_permission.__name__, + function=cls.clone_permission.__name__, argument="permission_id", ) cmd = XmlCommand("create_permission") - cmd.add_element("copy", permission_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(permission_id)) + return cmd + @classmethod def create_permission( - self, + cls, name: str, - subject_id: str, - subject_type: PermissionSubjectType, + subject_id: EntityID, + subject_type: Union[PermissionSubjectType, str], *, resource_id: Optional[str] = None, - resource_type: Optional[EntityType] = None, + resource_type: Optional[Union[EntityType, str]] = None, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new permission - Arguments: + Args: name: Name of the new permission subject_id: UUID of subject to whom the permission is granted subject_type: Type of the subject user, group or role @@ -60,32 +62,25 @@ def create_permission( resource_id: UUID of entity to which the permission applies resource_type: Type of the resource. For Super permissions user, group or role - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_permission.__name__, argument="name" + function=cls.create_permission.__name__, argument="name" ) if not subject_id: raise RequiredArgument( - function=self.create_permission.__name__, argument="subject_id" + function=cls.create_permission.__name__, argument="subject_id" ) if not isinstance(subject_type, PermissionSubjectType): - raise InvalidArgumentType( - function=self.create_permission.__name__, - argument="subject_type", - arg_type=PermissionSubjectType.__name__, - ) + subject_type = PermissionSubjectType(subject_type) cmd = XmlCommand("create_permission") cmd.add_element("name", name) - _xmlsubject = cmd.add_element("subject", attrs={"id": subject_id}) - _xmlsubject.add_element("type", subject_type.value) + xml_subject = cmd.add_element("subject", attrs={"id": str(subject_id)}) + xml_subject.add_element("type", subject_type.value) if comment: cmd.add_element("comment", comment) @@ -93,117 +88,110 @@ def create_permission( if resource_id or resource_type: if not resource_id: raise RequiredArgument( - function=self.create_permission.__name__, + function=cls.create_permission.__name__, argument="resource_id", ) if not resource_type: raise RequiredArgument( - function=self.create_permission.__name__, + function=cls.create_permission.__name__, argument="resource_type", ) if not isinstance(resource_type, EntityType): - raise InvalidArgumentType( - function=self.create_permission.__name__, - argument="resource_type", - arg_type=EntityType.__name__, - ) + resource_type = EntityType(resource_type) - _xmlresource = cmd.add_element( + xml_resource = cmd.add_element( "resource", attrs={"id": resource_id} ) - _actual_resource_type = resource_type + actual_resource_type = resource_type if resource_type.value == EntityType.AUDIT.value: - _actual_resource_type = EntityType.TASK + actual_resource_type = EntityType.TASK elif resource_type.value == EntityType.POLICY.value: - _actual_resource_type = EntityType.SCAN_CONFIG + actual_resource_type = EntityType.SCAN_CONFIG - _xmlresource.add_element("type", _actual_resource_type.value) + xml_resource.add_element("type", actual_resource_type.value) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_permission( - self, permission_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, permission_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing permission - Arguments: + Args: permission_id: UUID of the permission to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not permission_id: raise RequiredArgument( - function=self.delete_permission.__name__, + function=cls.delete_permission.__name__, argument="permission_id", ) cmd = XmlCommand("delete_permission") - cmd.set_attribute("permission_id", permission_id) + cmd.set_attribute("permission_id", str(permission_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_permissions( - self, *, filter_string: Optional[str] = None, filter_id: Optional[str] = None, trash: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of permissions - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get permissions in the trashcan instead - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_permissions") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd - def get_permission(self, permission_id: str) -> Any: + @classmethod + def get_permission(cls, permission_id: EntityID) -> Request: """Request a single permission - Arguments: + Args: permission_id: UUID of an existing permission - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_permissions") if not permission_id: raise RequiredArgument( - function=self.get_permission.__name__, argument="permission_id" + function=cls.get_permission.__name__, argument="permission_id" ) - cmd.set_attribute("permission_id", permission_id) - return self._send_xml_command(cmd) + cmd.set_attribute("permission_id", str(permission_id)) + return cmd + @classmethod def modify_permission( - self, - permission_id: str, + cls, + permission_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, - resource_id: Optional[str] = None, - resource_type: Optional[EntityType] = None, - subject_id: Optional[str] = None, - subject_type: Optional[PermissionSubjectType] = None, - ) -> Any: + resource_id: Optional[EntityID] = None, + resource_type: Optional[Union[EntityType, str]] = None, + subject_id: Optional[EntityID] = None, + subject_type: Optional[Union[PermissionSubjectType, str]] = None, + ) -> Request: """Modifies an existing permission. - Arguments: + Args: permission_id: UUID of permission to be modified. comment: The comment on the permission. name: Permission name, currently the name of a command. @@ -212,18 +200,15 @@ def modify_permission( resource_id: UUID of entity to which the permission applies resource_type: Type of the resource. For Super permissions user, group or role - - Returns: - The response. See :py:meth:`send_command` for details. """ if not permission_id: raise RequiredArgument( - function=self.modify_permission.__name__, + function=cls.modify_permission.__name__, argument="permission_id", ) cmd = XmlCommand("modify_permission") - cmd.set_attribute("permission_id", permission_id) + cmd.set_attribute("permission_id", str(permission_id)) if comment: cmd.add_element("comment", comment) @@ -234,48 +219,48 @@ def modify_permission( if resource_id or resource_type: if not resource_id: raise RequiredArgument( - function=self.modify_permission.__name__, + function=cls.modify_permission.__name__, argument="resource_id", ) if not resource_type: raise RequiredArgument( - function=self.modify_permission.__name__, + function=cls.modify_permission.__name__, argument="resource_type", ) if not isinstance(resource_type, EntityType): - raise InvalidArgumentType( - function=self.modify_permission.__name__, - argument="resource_type", - arg_type=EntityType.__name__, - ) + resource_type = EntityType(resource_type) - _xmlresource = cmd.add_element( - "resource", attrs={"id": resource_id} + xml_resource = cmd.add_element( + "resource", attrs={"id": str(resource_id)} ) - _actual_resource_type = resource_type + actual_resource_type = resource_type if resource_type.value == EntityType.AUDIT.value: - _actual_resource_type = EntityType.TASK + actual_resource_type = EntityType.TASK elif resource_type.value == EntityType.POLICY.value: - _actual_resource_type = EntityType.SCAN_CONFIG - _xmlresource.add_element("type", _actual_resource_type.value) + actual_resource_type = EntityType.SCAN_CONFIG + xml_resource.add_element("type", actual_resource_type.value) if subject_id or subject_type: if not subject_id: raise RequiredArgument( - function=self.modify_permission.__name__, + function=cls.modify_permission.__name__, argument="subject_id", ) - if not isinstance(subject_type, PermissionSubjectType): - raise InvalidArgumentType( - function=self.modify_permission.__name__, + if not subject_type: + raise RequiredArgument( + function=cls.modify_permission.__name__, argument="subject_type", - arg_type=PermissionSubjectType.__name__, ) - _xmlsubject = cmd.add_element("subject", attrs={"id": subject_id}) - _xmlsubject.add_element("type", subject_type.value) + if not isinstance(subject_type, PermissionSubjectType): + subject_type = PermissionSubjectType(subject_type) + + xml_subject = cmd.add_element( + "subject", attrs={"id": str(subject_id)} + ) + xml_subject.add_element("type", subject_type.value) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/policies.py b/gvm/protocols/gmp/requests/v224/_policies.py similarity index 60% rename from gvm/protocols/gmpv208/entities/policies.py rename to gvm/protocols/gmp/requests/v224/_policies.py index d01643ca7..c07569d8a 100644 --- a/gvm/protocols/gmpv208/entities/policies.py +++ b/gvm/protocols/gmp/requests/v224/_policies.py @@ -1,51 +1,52 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, List, Optional, Tuple +from typing import Optional, Sequence -from lxml.etree import XMLSyntaxError +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_base64, to_bool +from gvm.xml import XmlCommand, XmlError -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, is_list_like, to_base64, to_bool -from gvm.xml import XmlCommand +from .._entity_id import EntityID _EMPTY_POLICY_ID = "085569ce-73ed-11df-83c3-002264764cea" -class PoliciesMixin: - def clone_policy(self, policy_id: str) -> Any: +class Policies: + + @classmethod + def clone_policy(cls, policy_id: EntityID) -> Request: """Clone a policy from an existing one - Arguments: + Args: policy_id: UUID of the existing policy - - Returns: - The response. See :py:meth:`send_command` for details. """ if not policy_id: raise RequiredArgument( - function=self.clone_policy.__name__, argument="policy_id" + function=cls.clone_policy.__name__, argument="policy_id" ) cmd = XmlCommand("create_config") - cmd.add_element("copy", policy_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(policy_id)) + return cmd + @classmethod def create_policy( - self, name: str, *, policy_id: str = None, comment: Optional[str] = None - ) -> Any: + cls, + name: str, + *, + policy_id: Optional[EntityID] = None, + comment: Optional[str] = None, + ) -> Request: """Create a new policy - Arguments: + Args: name: Name of the new policy policy_id: UUID of an existing policy as base. By default the empty policy is used. comment: A comment on the policy - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("create_config") @@ -53,49 +54,53 @@ def create_policy( policy_id = _EMPTY_POLICY_ID if not name: raise RequiredArgument( - function=self.create_policy.__name__, argument="name" + function=cls.create_policy.__name__, argument="name" ) if comment is not None: cmd.add_element("comment", comment) - cmd.add_element("copy", policy_id) + + cmd.add_element("copy", str(policy_id)) cmd.add_element("name", name) cmd.add_element("usage_type", "policy") - return self._send_xml_command(cmd) + return cmd + + @classmethod def delete_policy( - self, policy_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, policy_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing policy - Arguments: + + Args: policy_id: UUID of the policy to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not policy_id: raise RequiredArgument( - function=self.delete_policy.__name__, argument="policy_id" + function=cls.delete_policy.__name__, argument="policy_id" ) cmd = XmlCommand("delete_config") - cmd.set_attribute("config_id", policy_id) + cmd.set_attribute("config_id", str(policy_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_policies( - self, *, audits: Optional[bool] = None, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, details: Optional[bool] = None, families: Optional[bool] = None, preferences: Optional[bool] = None, trash: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of policies - Arguments: + Args: audits: Whether to get audits using the policy filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query @@ -106,14 +111,11 @@ def get_policies( preferences: Whether to include the preferences if no details are requested trash: Whether to get the trashcan audits instead - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_configs") cmd.set_attribute("usage_type", "policy") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -130,27 +132,25 @@ def get_policies( if audits is not None: cmd.set_attribute("tasks", to_bool(audits)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_policy( - self, policy_id: str, *, audits: Optional[bool] = None - ) -> Any: + cls, policy_id: EntityID, *, audits: Optional[bool] = None + ) -> Request: """Request a single policy - Arguments: + Args: policy_id: UUID of an existing policy audits: Whether to get audits using this policy - - Returns: - The response. See :py:meth:`send_command` for details. """ if not policy_id: raise RequiredArgument( - function=self.get_policy.__name__, argument="policy_id" + function=cls.get_policy.__name__, argument="policy_id" ) cmd = XmlCommand("get_configs") - cmd.set_attribute("config_id", policy_id) + cmd.set_attribute("config_id", str(policy_id)) cmd.set_attribute("usage_type", "policy") @@ -160,45 +160,44 @@ def get_policy( # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd - def import_policy(self, policy: str) -> Any: + @classmethod + def import_policy(cls, policy: str) -> Request: """Import a policy from XML - Arguments: + Args: policy: Policy XML as string to import. This XML must contain a :code:`` root element. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not policy: raise RequiredArgument( - function=self.import_policy.__name__, argument="policy" + function=cls.import_policy.__name__, argument="policy" ) cmd = XmlCommand("create_config") try: cmd.append_xml_str(policy) - except XMLSyntaxError as e: + except XmlError as e: raise InvalidArgument( - function=self.import_policy.__name__, argument="policy" + function=cls.import_policy.__name__, argument="policy" ) from e - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_policy_set_nvt_preference( - self, - policy_id: str, + cls, + policy_id: EntityID, name: str, nvt_oid: str, *, value: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies the nvt preferences of an existing policy. - Arguments: + Args: policy_id: UUID of policy to modify. name: Name for preference to change. nvt_oid: OID of the NVT associated with preference to modify @@ -207,51 +206,52 @@ def modify_policy_set_nvt_preference( """ if not policy_id: raise RequiredArgument( - function=self.modify_policy_set_nvt_preference.__name__, + function=cls.modify_policy_set_nvt_preference.__name__, argument="policy_id", ) if not nvt_oid: raise RequiredArgument( - function=self.modify_policy_set_nvt_preference.__name__, + function=cls.modify_policy_set_nvt_preference.__name__, argument="nvt_oid", ) if not name: raise RequiredArgument( - function=self.modify_policy_set_nvt_preference.__name__, + function=cls.modify_policy_set_nvt_preference.__name__, argument="name", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(policy_id)) - _xmlpref = cmd.add_element("preference") + xml_pref = cmd.add_element("preference") - _xmlpref.add_element("nvt", attrs={"oid": nvt_oid}) - _xmlpref.add_element("name", name) + xml_pref.add_element("nvt", attrs={"oid": nvt_oid}) + xml_pref.add_element("name", name) if value: - _xmlpref.add_element("value", to_base64(value)) + xml_pref.add_element("value", to_base64(value)) - return self._send_xml_command(cmd) + return cmd - def modify_policy_set_name(self, policy_id: str, name: str) -> Any: + @classmethod + def modify_policy_set_name(cls, policy_id: EntityID, name: str) -> Request: """Modifies the name of an existing policy - Arguments: + Args: policy_id: UUID of policy to modify. name: New name for the policy. """ if not policy_id: raise RequiredArgument( - function=self.modify_policy_set_name.__name__, + function=cls.modify_policy_set_name.__name__, argument="policy_id", ) if not name: raise RequiredArgument( - function=self.modify_policy_set_name.__name__, + function=cls.modify_policy_set_name.__name__, argument="name", ) @@ -260,14 +260,15 @@ def modify_policy_set_name(self, policy_id: str, name: str) -> Any: cmd.add_element("name", name) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_policy_set_comment( - self, policy_id: str, comment: Optional[str] = None - ) -> Any: + cls, policy_id: EntityID, comment: Optional[str] = None + ) -> Request: """Modifies the comment of an existing policy - Arguments: + Args: policy_id: UUID of policy to modify. comment: Comment to set on a policy. Default is an empty comment and the previous comment will be @@ -275,7 +276,7 @@ def modify_policy_set_comment( """ if not policy_id: raise RequiredArgument( - function=self.modify_policy_set_comment.__name__, + function=cls.modify_policy_set_comment.__name__, argument="policy_id", ) @@ -285,98 +286,99 @@ def modify_policy_set_comment( comment = "" cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_policy_set_scanner_preference( - self, policy_id: str, name: str, *, value: Optional[str] = None - ) -> Any: + cls, policy_id: EntityID, name: str, *, value: Optional[str] = None + ) -> Request: """Modifies the scanner preferences of an existing policy - Arguments: + Args: policy_id: UUID of policy to modify. name: Name of the scanner preference to change value: New value for the preference. None to delete the preference and to use the default instead. - """ if not policy_id: raise RequiredArgument( - function=(self.modify_policy_set_scanner_preference.__name__), + function=cls.modify_policy_set_scanner_preference.__name__, argument="policy_id", ) if not name: raise RequiredArgument( - function=(self.modify_policy_set_scanner_preference.__name__), + function=cls.modify_policy_set_scanner_preference.__name__, argument="name argument", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(policy_id)) - _xmlpref = cmd.add_element("preference") + xml_pref = cmd.add_element("preference") - _xmlpref.add_element("name", name) + xml_pref.add_element("name", name) if value: - _xmlpref.add_element("value", to_base64(value)) + xml_pref.add_element("value", to_base64(value)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_policy_set_nvt_selection( - self, policy_id: str, family: str, nvt_oids: List[str] - ) -> Any: + cls, policy_id: EntityID, family: str, nvt_oids: Sequence[str] + ) -> Request: """Modifies the selected nvts of an existing policy The manager updates the given family in the policy to include only the given NVTs. - Arguments: + Args: policy_id: UUID of policy to modify. family: Name of the NVT family to include NVTs from nvt_oids: List of NVTs to select for the family. """ if not policy_id: raise RequiredArgument( - function=self.modify_policy_set_nvt_selection.__name__, + function=cls.modify_policy_set_nvt_selection.__name__, argument="policy_id", ) if not family: raise RequiredArgument( - function=self.modify_policy_set_nvt_selection.__name__, - argument="family argument", + function=cls.modify_policy_set_nvt_selection.__name__, + argument="family", ) - if not is_list_like(nvt_oids): - raise InvalidArgumentType( - function=self.modify_policy_set_nvt_selection.__name__, + if nvt_oids is None: + raise RequiredArgument( + function=cls.modify_policy_set_nvt_selection.__name__, argument="nvt_oids", - arg_type="list", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(policy_id)) - _xmlnvtsel = cmd.add_element("nvt_selection") - _xmlnvtsel.add_element("family", family) + xml_nvt_selection = cmd.add_element("nvt_selection") + xml_nvt_selection.add_element("family", family) for nvt in nvt_oids: - _xmlnvtsel.add_element("nvt", attrs={"oid": nvt}) + xml_nvt_selection.add_element("nvt", attrs={"oid": str(nvt)}) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_policy_set_family_selection( - self, - policy_id: str, - families: List[Tuple[str, bool, bool]], + cls, + policy_id: EntityID, + families: Sequence[tuple[str, bool, bool]], *, auto_add_new_families: Optional[bool] = True, - ) -> Any: + ) -> Request: """ Selected the NVTs of a policy at a family level. - Arguments: + Args: policy_id: UUID of policy to modify. families: A list of tuples with the first entry being the name of the NVT family selected, second entry a boolean indicating @@ -388,42 +390,34 @@ def modify_policy_set_family_selection( """ if not policy_id: raise RequiredArgument( - function=self.modify_policy_set_family_selection.__name__, + function=cls.modify_policy_set_family_selection.__name__, argument="policy_id", ) - if not is_list_like(families): - raise InvalidArgumentType( - function=self.modify_policy_set_family_selection.__name__, + if families is None: + raise RequiredArgument( + function=cls.modify_policy_set_family_selection.__name__, argument="families", - arg_type="list", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(policy_id)) - _xmlfamsel = cmd.add_element("family_selection") - _xmlfamsel.add_element("growing", to_bool(auto_add_new_families)) + xml_family_selection = cmd.add_element("family_selection") + xml_family_selection.add_element( + "growing", to_bool(auto_add_new_families) + ) for family in families: - _xmlfamily = _xmlfamsel.add_element("family") - _xmlfamily.add_element("name", family[0]) + xml_family = xml_family_selection.add_element("family") if len(family) != 3: raise InvalidArgument( "Family must be a tuple of 3. (str, bool, bool)" ) - if not isinstance(family[1], bool) or not isinstance( - family[2], bool - ): - raise InvalidArgumentType( - function=(self.modify_policy_set_family_selection.__name__), - argument="families", - arg_type="[tuple(str, bool, bool)]", - ) - - _xmlfamily.add_element("all", to_bool(family[2])) - _xmlfamily.add_element("growing", to_bool(family[1])) + xml_family.add_element("name", family[0]) + xml_family.add_element("all", to_bool(family[2])) + xml_family.add_element("growing", to_bool(family[1])) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/port_lists.py b/gvm/protocols/gmp/requests/v224/_port_lists.py similarity index 60% rename from gvm/protocols/gmpv208/entities/port_lists.py rename to gvm/protocols/gmp/requests/v224/_port_lists.py index 8342514c3..7dc2608c3 100644 --- a/gvm/protocols/gmpv208/entities/port_lists.py +++ b/gvm/protocols/gmp/requests/v224/_port_lists.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class PortRangeType(Enum): """Enum for port range type""" @@ -18,47 +20,43 @@ class PortRangeType(Enum): UDP = "UDP" -class PortListMixin: - def clone_port_list(self, port_list_id: str) -> Any: +class PortLists: + @classmethod + def clone_port_list(cls, port_list_id: EntityID) -> Request: """Clone an existing port list - Arguments: + Args: port_list_id: UUID of an existing port list to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not port_list_id: raise RequiredArgument( - function=self.clone_port_list.__name__, argument="port_list_id" + function=cls.clone_port_list.__name__, argument="port_list_id" ) cmd = XmlCommand("create_port_list") - cmd.add_element("copy", port_list_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(port_list_id)) + return cmd + @classmethod def create_port_list( - self, name: str, port_range: str, *, comment: Optional[str] = None - ) -> Any: + cls, name: str, port_range: str, *, comment: Optional[str] = None + ) -> Request: """Create a new port list - Arguments: + Args: name: Name of the new port list port_range: Port list ranges e.g. `"T: 1-1234"` for tcp port 1 - 1234 comment: Comment for the port list - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_port_list.__name__, argument="name" + function=cls.create_port_list.__name__, argument="name" ) if not port_range: raise RequiredArgument( - function=self.create_port_list.__name__, argument="port_range" + function=cls.create_port_list.__name__, argument="port_range" ) cmd = XmlCommand("create_port_list") @@ -68,60 +66,54 @@ def create_port_list( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def create_port_range( - self, - port_list_id: str, + cls, + port_list_id: EntityID, start: int, end: int, - port_range_type: PortRangeType, + port_range_type: Union[str, PortRangeType], *, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create new port range - Arguments: + Args: port_list_id: UUID of the port list to which to add the range start: The first port in the range end: The last port in the range port_range_type: The type of the ports: TCP, UDP, ... comment: Comment for the port range - - Returns: - The response. See :py:meth:`send_command` for details. """ if not port_list_id: raise RequiredArgument( - function=self.create_port_range.__name__, + function=cls.create_port_range.__name__, argument="port_list_id", ) if not port_range_type: raise RequiredArgument( - function=self.create_port_range.__name__, + function=cls.create_port_range.__name__, argument="port_range_type", ) if not start: raise RequiredArgument( - function=self.create_port_range.__name__, argument="start" + function=cls.create_port_range.__name__, argument="start" ) if not end: raise RequiredArgument( - function=self.create_port_range.__name__, argument="end" + function=cls.create_port_range.__name__, argument="end" ) if not isinstance(port_range_type, PortRangeType): - raise InvalidArgumentType( - function=self.create_port_range.__name__, - argument="port_range_type", - arg_type=PortRangeType.__name__, - ) + port_range_type = PortRangeType(port_range_type) cmd = XmlCommand("create_port_range") - cmd.add_element("port_list", attrs={"id": port_list_id}) + cmd.add_element("port_list", attrs={"id": str(port_list_id)}) cmd.add_element("start", str(start)) cmd.add_element("end", str(end)) cmd.add_element("type", port_range_type.value) @@ -129,69 +121,69 @@ def create_port_range( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_port_list( - self, port_list_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, port_list_id: EntityID, *, ultimate: bool = False + ) -> Request: """Deletes an existing port list - Arguments: + Args: port_list_id: UUID of the port list to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not port_list_id: raise RequiredArgument( - function=self.delete_port_list.__name__, argument="port_list_id" + function=cls.delete_port_list.__name__, argument="port_list_id" ) cmd = XmlCommand("delete_port_list") - cmd.set_attribute("port_list_id", port_list_id) + cmd.set_attribute("port_list_id", str(port_list_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd - def delete_port_range(self, port_range_id: str) -> Any: + @classmethod + def delete_port_range(cls, port_range_id: EntityID) -> Request: """Deletes an existing port range - Arguments: + Args: port_range_id: UUID of the port range to be deleted. """ if not port_range_id: raise RequiredArgument( - function=self.delete_port_range.__name__, + function=cls.delete_port_range.__name__, argument="port_range_id", ) cmd = XmlCommand("delete_port_range") - cmd.set_attribute("port_range_id", port_range_id) + cmd.set_attribute("port_range_id", str(port_range_id)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_port_lists( - self, + cls, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, details: Optional[bool] = None, targets: Optional[bool] = None, trash: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of port lists - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query details: Whether to include full port list details targets: Whether to include targets using this port list trash: Whether to get port lists in the trashcan instead - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_port_lists") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) @@ -202,54 +194,50 @@ def get_port_lists( if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd - def get_port_list(self, port_list_id: str): + @classmethod + def get_port_list(cls, port_list_id: EntityID) -> Request: """Request a single port list - Arguments: + Args: port_list_id: UUID of an existing port list - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_port_lists") if not port_list_id: raise RequiredArgument( - function=self.get_port_list.__name__, argument="port_list_id" + function=cls.get_port_list.__name__, argument="port_list_id" ) - cmd.set_attribute("port_list_id", port_list_id) + cmd.set_attribute("port_list_id", str(port_list_id)) # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_port_list( - self, - port_list_id: str, + cls, + port_list_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies an existing port list. - Arguments: + Args: port_list_id: UUID of port list to modify. name: Name of port list. comment: Comment on port list. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not port_list_id: raise RequiredArgument( - function=self.modify_port_list.__name__, argument="port_list_id" + function=cls.modify_port_list.__name__, argument="port_list_id" ) cmd = XmlCommand("modify_port_list") - cmd.set_attribute("port_list_id", port_list_id) + cmd.set_attribute("port_list_id", str(port_list_id)) if comment: cmd.add_element("comment", comment) @@ -257,4 +245,4 @@ def modify_port_list( if name: cmd.add_element("name", name) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/report_formats.py b/gvm/protocols/gmp/requests/v224/_report_formats.py similarity index 65% rename from gvm/protocols/gmpv208/entities/report_formats.py rename to gvm/protocols/gmp/requests/v224/_report_formats.py index b87975d85..fbf2e5d30 100644 --- a/gvm/protocols/gmpv208/entities/report_formats.py +++ b/gvm/protocols/gmp/requests/v224/_report_formats.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from typing import Any, Optional, Union - -from lxml.etree import XMLSyntaxError +from typing import Optional, Union from gvm._enum import Enum from gvm.errors import InvalidArgument, RequiredArgument -from gvm.utils import add_filter, to_bool -from gvm.xml import XmlCommand +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand, XmlError + +from .._entity_id import EntityID class ReportFormatType(Enum): @@ -36,90 +37,83 @@ class ReportFormatType(Enum): VERINICE_ITG = "50c9950a-f326-11e4-800c-28d24461215b" XML = "a994b278-1f62-11e1-96ac-406186ea4fc5" + def __str__(self) -> str: + return self.value + -class ReportFormatsMixin: +class ReportFormats: + + @classmethod def clone_report_format( - self, report_format_id: Union[str, ReportFormatType] - ) -> Any: + cls, report_format_id: Union[EntityID, ReportFormatType] + ) -> Request: """Clone a report format from an existing one - Arguments: + Args: report_format_id: UUID of the existing report format or ReportFormatType (enum) - - Returns: - The response. See :py:meth:`send_command` for details. """ if not report_format_id: raise RequiredArgument( - function=self.clone_report_format.__name__, + function=cls.clone_report_format.__name__, argument="report_format_id", ) cmd = XmlCommand("create_report_format") + cmd.add_element("copy", str(report_format_id)) + return cmd - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.add_element("copy", report_format_id) - return self._send_xml_command(cmd) - + @classmethod def delete_report_format( - self, - report_format_id: Optional[Union[str, ReportFormatType]] = None, + cls, + report_format_id: Union[EntityID, ReportFormatType], *, ultimate: Optional[bool] = False, - ) -> Any: + ) -> Request: """Deletes an existing report format - Arguments: + Args: report_format_id: UUID of the report format to be deleted. or ReportFormatType (enum) ultimate: Whether to remove entirely, or to the trashcan. """ if not report_format_id: raise RequiredArgument( - function=self.delete_report_format.__name__, + function=cls.delete_report_format.__name__, argument="report_format_id", ) cmd = XmlCommand("delete_report_format") - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.set_attribute("report_format_id", report_format_id) + cmd.set_attribute("report_format_id", str(report_format_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_report_formats( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, alerts: Optional[bool] = None, params: Optional[bool] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of report formats - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan report formats instead alerts: Whether to include alerts that use the report format params: Whether to include report format parameters details: Include report format file, signature and parameters - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_report_formats") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) @@ -133,48 +127,43 @@ def get_report_formats( if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_report_format( - self, report_format_id: Union[str, ReportFormatType] - ) -> Any: + cls, report_format_id: Union[EntityID, ReportFormatType] + ) -> Request: """Request a single report format - Arguments: + Args: report_format_id: UUID of an existing report format or ReportFormatType (enum) - Returns: - The response. See :py:meth:`send_command` for details. """ - cmd = XmlCommand("get_report_formats") if not report_format_id: raise RequiredArgument( - function=self.get_report_format.__name__, + function=cls.get_report_format.__name__, argument="report_format_id", ) - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value + cmd = XmlCommand("get_report_formats") - cmd.set_attribute("report_format_id", report_format_id) + cmd.set_attribute("report_format_id", str(report_format_id)) # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd - def import_report_format(self, report_format: str) -> Any: + @classmethod + def import_report_format(cls, report_format: str) -> Request: """Import a report format from XML - Arguments: + Args: report_format: Report format XML as string to import. This XML must contain a :code:`` root element. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not report_format: raise RequiredArgument( - function=self.import_report_format.__name__, + function=cls.import_report_format.__name__, argument="report_format", ) @@ -182,27 +171,28 @@ def import_report_format(self, report_format: str) -> Any: try: cmd.append_xml_str(report_format) - except XMLSyntaxError as e: + except XmlError as e: raise InvalidArgument( - function=self.import_report_format.__name__, + function=cls.import_report_format.__name__, argument="report_format", ) from e - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_report_format( - self, - report_format_id: Optional[Union[str, ReportFormatType]] = None, + cls, + report_format_id: Union[EntityID, ReportFormatType], *, active: Optional[bool] = None, name: Optional[str] = None, summary: Optional[str] = None, param_name: Optional[str] = None, param_value: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies an existing report format. - Arguments: + Args: report_format_id: UUID of report format to modify or ReportFormatType (enum) active: Whether the report format is active. @@ -210,22 +200,16 @@ def modify_report_format( summary: A summary of the report format. param_name: The name of the param. param_value: The value of the param. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not report_format_id: raise RequiredArgument( - function=self.modify_report_format.__name__, + function=cls.modify_report_format.__name__, argument="report_format_id ", ) cmd = XmlCommand("modify_report_format") - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.set_attribute("report_format_id", report_format_id) + cmd.set_attribute("report_format_id", str(report_format_id)) if active is not None: cmd.add_element("active", to_bool(active)) @@ -237,17 +221,18 @@ def modify_report_format( cmd.add_element("summary", summary) if param_name: - _xmlparam = cmd.add_element("param") - _xmlparam.add_element("name", param_name) + xml_param = cmd.add_element("param") + xml_param.add_element("name", param_name) if param_value is not None: - _xmlparam.add_element("value", param_value) + xml_param.add_element("value", param_value) - return self._send_xml_command(cmd) + return cmd + @classmethod def verify_report_format( - self, report_format_id: Union[str, ReportFormatType] - ) -> Any: + cls, report_format_id: Union[EntityID, ReportFormatType] + ) -> Request: """Verify an existing report format Verifies the trust level of an existing report format. It will be @@ -256,24 +241,16 @@ def verify_report_format( reports of this format. It is *not* verified if the report format works as expected by the user. - Arguments: + Args: report_format_id: UUID of the report format to be verified or ReportFormatType (enum) - - Returns: - The response. See :py:meth:`send_command` for details. """ if not report_format_id: raise RequiredArgument( - function=self.verify_report_format.__name__, + function=cls.verify_report_format.__name__, argument="report_format_id", ) cmd = XmlCommand("verify_report_format") - - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.set_attribute("report_format_id", report_format_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("report_format_id", str(report_format_id)) + return cmd diff --git a/gvm/protocols/gmpv208/entities/reports.py b/gvm/protocols/gmp/requests/v224/_reports.py similarity index 65% rename from gvm/protocols/gmpv208/entities/reports.py rename to gvm/protocols/gmp/requests/v224/_reports.py index e0656fced..16af26457 100644 --- a/gvm/protocols/gmpv208/entities/reports.py +++ b/gvm/protocols/gmp/requests/v224/_reports.py @@ -1,51 +1,52 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, Optional, Union -from lxml.etree import XMLSyntaxError +from typing import Optional, Union from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand, XmlError + +from .._entity_id import EntityID +from ._report_formats import ReportFormatType -# if I use latest, I get circular import :/ -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType -from gvm.utils import add_filter, to_bool -from gvm.xml import XmlCommand +class Reports: -class ReportsMixin: - def delete_report(self, report_id: str) -> Any: + @classmethod + def delete_report(cls, report_id: EntityID) -> Request: """Deletes an existing report - Arguments: + Args: report_id: UUID of the report to be deleted. """ if not report_id: raise RequiredArgument( - function=self.delete_report.__name__, argument="report_id" + function=cls.delete_report.__name__, argument="report_id" ) cmd = XmlCommand("delete_report") - cmd.set_attribute("report_id", report_id) + cmd.set_attribute("report_id", str(report_id)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_report( - self, - report_id: str, + cls, + report_id: EntityID, *, filter_string: Optional[str] = None, filter_id: Optional[str] = None, - delta_report_id: Optional[str] = None, + delta_report_id: Optional[EntityID] = None, report_format_id: Optional[Union[str, ReportFormatType]] = None, ignore_pagination: Optional[bool] = None, details: Optional[bool] = True, - ) -> Any: + ) -> Request: """Request a single report - Arguments: + Args: report_id: UUID of an existing report filter_string: Filter term to use to filter results in the report filter_id: UUID of filter to use to filter results in the report @@ -56,50 +57,44 @@ def get_report( "rows". details: Request additional report information details defaults to True - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_reports") if not report_id: raise RequiredArgument( - function=self.get_report.__name__, argument="report_id" + function=cls.get_report.__name__, argument="report_id" ) - cmd.set_attribute("report_id", report_id) + cmd.set_attribute("report_id", str(report_id)) - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if delta_report_id: - cmd.set_attribute("delta_report_id", delta_report_id) + cmd.set_attribute("delta_report_id", str(delta_report_id)) if report_format_id: - if isinstance(report_format_id, ReportFormatType): - report_format_id = report_format_id.value - - cmd.set_attribute("format_id", report_format_id) + cmd.set_attribute("format_id", str(report_format_id)) if ignore_pagination is not None: cmd.set_attribute("ignore_pagination", to_bool(ignore_pagination)) cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_reports( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, note_details: Optional[bool] = None, override_details: Optional[bool] = None, ignore_pagination: Optional[bool] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of reports - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query note_details: If notes are included, whether to include note details @@ -108,9 +103,6 @@ def get_reports( ignore_pagination: Whether to ignore the filter terms "first" and "rows". details: Whether to exclude results - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_reports") @@ -118,7 +110,7 @@ def get_reports( cmd.set_attribute("report_filter", filter_string) if filter_id: - cmd.set_attribute("report_filt_id", filter_id) + cmd.set_attribute("report_filt_id", str(filter_id)) if note_details is not None: cmd.set_attribute("note_details", to_bool(note_details)) @@ -132,48 +124,46 @@ def get_reports( if ignore_pagination is not None: cmd.set_attribute("ignore_pagination", to_bool(ignore_pagination)) - return self._send_xml_command(cmd) + return cmd + @classmethod def import_report( - self, + cls, report: str, + task_id: EntityID, *, - task_id: Optional[str] = None, in_assets: Optional[bool] = None, - ) -> Any: + ) -> Request: """Import a Report from XML - Arguments: + Args: report: Report XML as string to import. This XML must contain a :code:`` root element. task_id: UUID of task to import report to in_asset: Whether to create or update assets using the report - - Returns: - The response. See :py:meth:`send_command` for details. """ if not report: raise RequiredArgument( - function=self.import_report.__name__, argument="report" + function=cls.import_report.__name__, argument="report" ) cmd = XmlCommand("create_report") - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - else: + if not task_id: raise RequiredArgument( - function=self.import_report.__name__, argument="task_id" + function=cls.import_report.__name__, argument="task_id" ) + cmd.add_element("task", attrs={"id": str(task_id)}) + if in_assets is not None: cmd.add_element("in_assets", to_bool(in_assets)) try: cmd.append_xml_str(report) - except XMLSyntaxError as e: + except XmlError as e: raise InvalidArgument( f"Invalid xml passed as report to import_report {e}" ) from None - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/results.py b/gvm/protocols/gmp/requests/v224/_results.py similarity index 70% rename from gvm/protocols/gmpv208/entities/results.py rename to gvm/protocols/gmp/requests/v224/_results.py index 115ed9c4a..d4e651983 100644 --- a/gvm/protocols/gmpv208/entities/results.py +++ b/gvm/protocols/gmp/requests/v224/_results.py @@ -1,40 +1,41 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + + +class Results: -class ResultsMixin: - def get_result(self, result_id: str) -> Any: + @classmethod + def get_result(cls, result_id: EntityID) -> Request: """Request a single result - Arguments: + Args: result_id: UUID of an existing result - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_results") if not result_id: raise RequiredArgument( - function=self.get_result.__name__, argument="result_id" + function=cls.get_result.__name__, argument="result_id" ) - cmd.set_attribute("result_id", result_id) + cmd.set_attribute("result_id", str(result_id)) # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_results( - self, *, filter_string: Optional[str] = None, filter_id: Optional[str] = None, @@ -42,10 +43,10 @@ def get_results( note_details: Optional[bool] = None, override_details: Optional[bool] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of results - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query task_id: UUID of task for note and override handling @@ -53,23 +54,21 @@ def get_results( override_details: If overrides are included, whether to include override details details: Whether to include additional details of the results - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_results") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if task_id: cmd.set_attribute("task_id", task_id) if details is not None: cmd.set_attribute("details", to_bool(details)) + if note_details is not None: cmd.set_attribute("note_details", to_bool(note_details)) if override_details is not None: cmd.set_attribute("override_details", to_bool(override_details)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/roles.py b/gvm/protocols/gmp/requests/v224/_roles.py similarity index 58% rename from gvm/protocols/gmpv208/entities/roles.py rename to gvm/protocols/gmp/requests/v224/_roles.py index 1aa809b3e..fffcbee09 100644 --- a/gvm/protocols/gmpv208/entities/roles.py +++ b/gvm/protocols/gmp/requests/v224/_roles.py @@ -1,55 +1,53 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, List, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool, to_comma_list +from gvm.protocols.core import Request +from gvm.utils import to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID + + +class Roles: -class RolesMixin: - def clone_role(self, role_id: str) -> Any: + @classmethod + def clone_role(cls, role_id: EntityID) -> Request: """Clone an existing role - Arguments: + Args: role_id: UUID of an existing role to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not role_id: raise RequiredArgument( - function=self.clone_role.__name__, argument="role_id" + function=cls.clone_role.__name__, argument="role_id" ) cmd = XmlCommand("create_role") - cmd.add_element("copy", role_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(role_id)) + return cmd + @classmethod def create_role( - self, + cls, name: str, *, comment: Optional[str] = None, - users: Optional[List[str]] = None, - ) -> Any: + users: Optional[list[str]] = None, + ) -> Request: """Create a new role - Arguments: + Args: name: Name of the role comment: Comment for the role users: List of user names to add to the role - - Returns: - The response. See :py:meth:`send_command` for details. """ - if not name: raise RequiredArgument( - function=self.create_role.__name__, argument="name" + function=cls.create_role.__name__, argument="name" ) cmd = XmlCommand("create_role") @@ -61,98 +59,91 @@ def create_role( if users: cmd.add_element("users", to_comma_list(users)) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_role( - self, role_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, role_id: str, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing role - Arguments: + Args: role_id: UUID of the role to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not role_id: raise RequiredArgument( - function=self.delete_role.__name__, argument="role_id" + function=cls.delete_role.__name__, argument="role_id" ) cmd = XmlCommand("delete_role") cmd.set_attribute("role_id", role_id) cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd - return self._send_xml_command(cmd) - + @staticmethod def get_roles( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of roles - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan roles instead - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_roles") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd - def get_role(self, role_id: str) -> Any: + @classmethod + def get_role(cls, role_id: EntityID) -> Request: """Request a single role - Arguments: + Args: role_id: UUID of an existing role - - Returns: - The response. See :py:meth:`send_command` for details. """ if not role_id: raise RequiredArgument( - function=self.get_role.__name__, argument="role_id" + function=cls.get_role.__name__, argument="role_id" ) cmd = XmlCommand("get_roles") - cmd.set_attribute("role_id", role_id) - return self._send_xml_command(cmd) + cmd.set_attribute("role_id", str(role_id)) + return cmd + @classmethod def modify_role( - self, - role_id: str, + cls, + role_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, - users: Optional[List[str]] = None, - ) -> Any: + users: Optional[list[str]] = None, + ) -> Request: """Modifies an existing role. - Arguments: + Args: role_id: UUID of role to modify. comment: Name of role. name: Comment on role. users: List of user names. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not role_id: raise RequiredArgument( - function=self.modify_role.__name__, argument="role_id argument" + function=cls.modify_role.__name__, argument="role_id argument" ) cmd = XmlCommand("modify_role") - cmd.set_attribute("role_id", role_id) + cmd.set_attribute("role_id", str(role_id)) if comment: cmd.add_element("comment", comment) @@ -163,4 +154,4 @@ def modify_role( if users: cmd.add_element("users", to_comma_list(users)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv224/entities/scan_configs.py b/gvm/protocols/gmp/requests/v224/_scan_configs.py similarity index 53% rename from gvm/protocols/gmpv224/entities/scan_configs.py rename to gvm/protocols/gmp/requests/v224/_scan_configs.py index 1b41ee426..f5070cb3a 100644 --- a/gvm/protocols/gmpv224/entities/scan_configs.py +++ b/gvm/protocols/gmp/requests/v224/_scan_configs.py @@ -1,101 +1,104 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional, Tuple -from lxml.etree import XMLSyntaxError +from typing import Optional, Union from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, deprecation, is_list_like, to_base64, to_bool -from gvm.xml import XmlCommand +from gvm.protocols.core import Request +from gvm.utils import is_list_like, to_base64, to_bool +from gvm.xml import XmlCommand, XmlError + +from .._entity_id import EntityID -class ScanConfigsMixin: - def clone_scan_config(self, config_id: str) -> Any: +class ScanConfigs: + @classmethod + def clone_scan_config(cls, config_id: EntityID) -> Request: """Clone a scan config from an existing one - Arguments: + Args: config_id: UUID of the existing scan config - - Returns: - The response. See :py:meth:`send_command` for details. """ if not config_id: raise RequiredArgument( - function=self.clone_scan_config.__name__, argument="config_id" + function=cls.clone_scan_config.__name__, argument="config_id" ) cmd = XmlCommand("create_config") - cmd.add_element("copy", config_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(config_id)) + return cmd + @classmethod def create_scan_config( - self, config_id: str, name: str, *, comment: Optional[str] = None - ) -> Any: + cls, + config_id: EntityID, + name: str, + *, + comment: Optional[str] = None, + ) -> Request: """Create a new scan config - Arguments: + Args: config_id: UUID of the existing scan config name: Name of the new scan config comment: A comment on the config - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_scan_config.__name__, argument="name" + function=cls.create_scan_config.__name__, argument="name" ) if not config_id: raise RequiredArgument( - function=self.create_scan_config.__name__, argument="config_id" + function=cls.create_scan_config.__name__, argument="config_id" ) cmd = XmlCommand("create_config") if comment is not None: cmd.add_element("comment", comment) - cmd.add_element("copy", config_id) + + cmd.add_element("copy", str(config_id)) cmd.add_element("name", name) cmd.add_element("usage_type", "scan") - return self._send_xml_command(cmd) + return cmd + + @classmethod def delete_scan_config( - self, config_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, config_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing config - Arguments: + Args: config_id: UUID of the config to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not config_id: raise RequiredArgument( - function=self.delete_scan_config.__name__, argument="config_id" + function=cls.delete_scan_config.__name__, argument="config_id" ) cmd = XmlCommand("delete_config") - cmd.set_attribute("config_id", config_id) + cmd.set_attribute("config_id", str(config_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_scan_configs( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, details: Optional[bool] = None, families: Optional[bool] = None, preferences: Optional[bool] = None, tasks: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of scan configs - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan scan configs instead @@ -106,14 +109,11 @@ def get_scan_configs( preferences: Whether to include the preferences if no details are requested tasks: Whether to get tasks using this config - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_configs") cmd.set_attribute("usage_type", "scan") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -130,27 +130,25 @@ def get_scan_configs( if tasks is not None: cmd.set_attribute("tasks", to_bool(tasks)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_scan_config( - self, config_id: str, *, tasks: Optional[bool] = None - ) -> Any: + cls, config_id: EntityID, *, tasks: Optional[bool] = None + ) -> Request: """Request a single scan config - Arguments: + Args: config_id: UUID of an existing scan config tasks: Whether to get tasks using this config - - Returns: - The response. See :py:meth:`send_command` for details. """ if not config_id: raise RequiredArgument( - function=self.get_scan_config.__name__, argument="config_id" + function=cls.get_scan_config.__name__, argument="config_id" ) cmd = XmlCommand("get_configs") - cmd.set_attribute("config_id", config_id) + cmd.set_attribute("config_id", str(config_id)) cmd.set_attribute("usage_type", "scan") @@ -160,11 +158,15 @@ def get_scan_config( # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @classmethod def get_scan_config_preferences( - self, *, nvt_oid: Optional[str] = None, config_id: Optional[str] = None - ) -> Any: + cls, + *, + nvt_oid: Optional[str] = None, + config_id: Optional[EntityID] = None, + ) -> Request: """Request a list of scan_config preferences When the command includes a config_id attribute, the preference element @@ -173,95 +175,89 @@ def get_scan_config_preferences( If the command includes a config_id and an nvt_oid, the preferences for the given nvt in the config will be shown. - Arguments: + Args: nvt_oid: OID of nvt config_id: UUID of scan config of which to show preference values - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_preferences") if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) + cmd.set_attribute("nvt_oid", str(nvt_oid)) if config_id: - cmd.set_attribute("config_id", config_id) + cmd.set_attribute("config_id", str(config_id)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_scan_config_preference( - self, + cls, name: str, *, nvt_oid: Optional[str] = None, - config_id: Optional[str] = None, - ) -> Any: + config_id: Optional[EntityID] = None, + ) -> Request: """Request a nvt preference - Arguments: + Args: name: name of a particular preference nvt_oid: OID of nvt config_id: UUID of scan config of which to show preference values - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_preferences") if not name: raise RequiredArgument( - function=self.get_scan_config_preference.__name__, + function=cls.get_scan_config_preference.__name__, argument="name", ) cmd.set_attribute("preference", name) if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) + cmd.set_attribute("nvt_oid", str(nvt_oid)) if config_id: - cmd.set_attribute("config_id", config_id) + cmd.set_attribute("config_id", str(config_id)) - return self._send_xml_command(cmd) + return cmd - def import_scan_config(self, config: str) -> Any: + @classmethod + def import_scan_config(cls, config: str) -> Request: """Import a scan config from XML - Arguments: + Args: config: Scan Config XML as string to import. This XML must contain a :code:`` root element. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not config: raise RequiredArgument( - function=self.import_scan_config.__name__, argument="config" + function=cls.import_scan_config.__name__, argument="config" ) cmd = XmlCommand("create_config") try: cmd.append_xml_str(config) - except XMLSyntaxError as e: + except XmlError as e: raise InvalidArgument( - function=self.import_scan_config.__name__, argument="config" + function=cls.import_scan_config.__name__, argument="config" ) from e - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_scan_config_set_nvt_preference( - self, - config_id: str, + cls, + config_id: EntityID, name: str, nvt_oid: str, *, value: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies the nvt preferences of an existing scan config. - Arguments: + Args: config_id: UUID of scan config to modify. name: Name for nvt preference to change. nvt_oid: OID of the NVT associated with preference to modify @@ -270,51 +266,54 @@ def modify_scan_config_set_nvt_preference( """ if not config_id: raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, + function=cls.modify_scan_config_set_nvt_preference.__name__, argument="config_id", ) if not nvt_oid: raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, + function=cls.modify_scan_config_set_nvt_preference.__name__, argument="nvt_oid", ) if not name: raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, + function=cls.modify_scan_config_set_nvt_preference.__name__, argument="name", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(config_id)) - _xmlpref = cmd.add_element("preference") + xml_preference = cmd.add_element("preference") - _xmlpref.add_element("nvt", attrs={"oid": nvt_oid}) - _xmlpref.add_element("name", name) + xml_preference.add_element("nvt", attrs={"oid": str(nvt_oid)}) + xml_preference.add_element("name", name) if value: - _xmlpref.add_element("value", to_base64(value)) + xml_preference.add_element("value", to_base64(value)) - return self._send_xml_command(cmd) + return cmd - def modify_scan_config_set_name(self, config_id: str, name: str) -> Any: + @classmethod + def modify_scan_config_set_name( + cls, config_id: EntityID, name: str + ) -> Request: """Modifies the name of an existing scan config - Arguments: + Args: config_id: UUID of scan config to modify. name: New name for the config. """ if not config_id: raise RequiredArgument( - function=self.modify_scan_config_set_name.__name__, + function=cls.modify_scan_config_set_name.__name__, argument="config_id", ) if not name: raise RequiredArgument( - function=self.modify_scan_config_set_name.__name__, + function=cls.modify_scan_config_set_name.__name__, argument="name", ) @@ -323,14 +322,15 @@ def modify_scan_config_set_name(self, config_id: str, name: str) -> Any: cmd.add_element("name", name) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_scan_config_set_comment( - self, config_id: str, *, comment: Optional[str] = None - ) -> Any: + cls, config_id: EntityID, *, comment: Optional[str] = None + ) -> Request: """Modifies the comment of an existing scan config - Arguments: + Args: config_id: UUID of scan config to modify. comment: Comment to set on a config. Default is an empty comment and the previous comment will be @@ -338,34 +338,40 @@ def modify_scan_config_set_comment( """ if not config_id: raise RequiredArgument( - function=self.modify_scan_config_set_comment.__name__, + function=cls.modify_scan_config_set_comment.__name__, argument="config_id argument", ) cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(config_id)) + if not comment: comment = "" + cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_scan_config_set_scanner_preference( - self, config_id: str, name: str, *, value: Optional[str] = None - ) -> Any: + cls, + config_id: EntityID, + name: str, + *, + value: Optional[str] = None, + ) -> Request: """Modifies the scanner preferences of an existing scan config - Arguments: + Args: config_id: UUID of scan config to modify. name: Name of the scanner preference to change value: New value for the preference. None to delete the preference and to use the default instead. - """ if not config_id: raise RequiredArgument( function=( - self.modify_scan_config_set_scanner_preference.__name__ + cls.modify_scan_config_set_scanner_preference.__name__ ), argument="config_id", ) @@ -373,7 +379,7 @@ def modify_scan_config_set_scanner_preference( if not name: raise RequiredArgument( function=( - self.modify_scan_config_set_scanner_preference.__name__ + cls.modify_scan_config_set_scanner_preference.__name__ ), argument="name argument", ) @@ -381,18 +387,22 @@ def modify_scan_config_set_scanner_preference( cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(config_id)) - _xmlpref = cmd.add_element("preference") + xml_preference = cmd.add_element("preference") - _xmlpref.add_element("name", name) + xml_preference.add_element("name", name) if value: - _xmlpref.add_element("value", to_base64(value)) + xml_preference.add_element("value", to_base64(value)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_scan_config_set_nvt_selection( - self, config_id: str, family: str, nvt_oids: List[str] - ) -> Any: + cls, + config_id: EntityID, + family: str, + nvt_oids: Union[tuple[str], list[str]], + ) -> Request: """Modifies the selected nvts of an existing scan config The manager updates the given family in the config to include only the @@ -405,19 +415,19 @@ def modify_scan_config_set_nvt_selection( """ if not config_id: raise RequiredArgument( - function=self.modify_scan_config_set_nvt_selection.__name__, + function=cls.modify_scan_config_set_nvt_selection.__name__, argument="config_id", ) if not family: raise RequiredArgument( - function=self.modify_scan_config_set_nvt_selection.__name__, + function=cls.modify_scan_config_set_nvt_selection.__name__, argument="family argument", ) if not is_list_like(nvt_oids): raise InvalidArgumentType( - function=self.modify_scan_config_set_nvt_selection.__name__, + function=cls.modify_scan_config_set_nvt_selection.__name__, argument="nvt_oids", arg_type="list", ) @@ -425,25 +435,26 @@ def modify_scan_config_set_nvt_selection( cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(config_id)) - _xmlnvtsel = cmd.add_element("nvt_selection") - _xmlnvtsel.add_element("family", family) + xmlnvtsel = cmd.add_element("nvt_selection") + xmlnvtsel.add_element("family", family) for nvt in nvt_oids: - _xmlnvtsel.add_element("nvt", attrs={"oid": nvt}) + xmlnvtsel.add_element("nvt", attrs={"oid": nvt}) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_scan_config_set_family_selection( - self, - config_id: str, - families: List[Tuple[str, bool, bool]], + cls, + config_id: EntityID, + families: list[tuple[str, bool, bool]], *, auto_add_new_families: Optional[bool] = True, - ) -> Any: + ) -> Request: """ Selected the NVTs of a scan config at a family level. - Arguments: + Args: config_id: UUID of scan config to modify. families: A list of tuples (str, bool, bool): str: the name of the NVT family selected, @@ -454,13 +465,13 @@ def modify_scan_config_set_family_selection( """ if not config_id: raise RequiredArgument( - function=self.modify_scan_config_set_family_selection.__name__, + function=cls.modify_scan_config_set_family_selection.__name__, argument="config_id", ) if not is_list_like(families): raise InvalidArgumentType( - function=self.modify_scan_config_set_family_selection.__name__, + function=cls.modify_scan_config_set_family_selection.__name__, argument="families", arg_type="list", ) @@ -468,12 +479,14 @@ def modify_scan_config_set_family_selection( cmd = XmlCommand("modify_config") cmd.set_attribute("config_id", str(config_id)) - _xmlfamsel = cmd.add_element("family_selection") - _xmlfamsel.add_element("growing", to_bool(auto_add_new_families)) + xml_family_selection = cmd.add_element("family_selection") + xml_family_selection.add_element( + "growing", to_bool(auto_add_new_families) + ) for family in families: - _xmlfamily = _xmlfamsel.add_element("family") - _xmlfamily.add_element("name", family[0]) + xml_family = xml_family_selection.add_element("family") + xml_family.add_element("name", family[0]) if len(family) != 3: raise InvalidArgument( @@ -485,98 +498,13 @@ def modify_scan_config_set_family_selection( ): raise InvalidArgumentType( function=( - self.modify_scan_config_set_family_selection.__name__ + cls.modify_scan_config_set_family_selection.__name__ ), argument="families", arg_type="[tuple(str, bool, bool)]", ) - _xmlfamily.add_element("all", to_bool(family[2])) - _xmlfamily.add_element("growing", to_bool(family[1])) - - return self._send_xml_command(cmd) - - def modify_scan_config( - self, config_id: str, selection: Optional[str] = None, **kwargs - ) -> Any: - """Modifies an existing scan config. - - DEPRECATED. Please use *modify_scan_config_set_* methods instead. - - modify_config has four modes to operate depending on the selection. - - Arguments: - config_id: UUID of scan config to modify. - selection: one of 'scan_pref', 'nvt_pref', 'nvt_selection' or - 'family_selection' - name: New name for preference. - value: New value for preference. - nvt_oids: List of NVTs associated with preference to modify. - family: Name of family to modify. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config.__name__, - argument="config_id argument", - ) + xml_family.add_element("all", to_bool(family[2])) + xml_family.add_element("growing", to_bool(family[1])) - if selection is None: - deprecation( - "Using modify_config to update the comment of a scan config is" - "deprecated. Please use modify_scan_config_set_comment instead." - ) - return self.modify_scan_config_set_comment( - config_id, comment=kwargs.get("comment") - ) - - if selection not in ( - "nvt_pref", - "scan_pref", - "family_selection", - "nvt_selection", - ): - raise InvalidArgument( - "selection must be one of nvt_pref, " - "scan_pref, family_selection or " - "nvt_selection" - ) - - if selection == "nvt_pref": - deprecation( - "Using modify_scan_config to update a nvt preference of a scan " - "config is deprecated. Please use " - "modify_scan_config_set_nvt_preference instead." - ) - return self.modify_scan_config_set_nvt_preference( - config_id, **kwargs - ) - - if selection == "scan_pref": - deprecation( - "Using modify_scan_config to update a scanner preference of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_scanner_preference instead." - ) - return self.modify_scan_config_set_scanner_preference( - config_id, **kwargs - ) - - if selection == "nvt_selection": - deprecation( - "Using modify_scan_config to update a nvt selection of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_nvt_selection instead." - ) - return self.modify_scan_config_set_nvt_selection( - config_id, **kwargs - ) - - deprecation( - "Using modify_scan_config to update a family selection of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_family_selection instead." - ) - return self.modify_scan_config_set_family_selection(config_id, **kwargs) + return cmd diff --git a/gvm/protocols/gmpv208/entities/scanners.py b/gvm/protocols/gmp/requests/v224/_scanners.py similarity index 52% rename from gvm/protocols/gmpv208/entities/scanners.py rename to gvm/protocols/gmp/requests/v224/_scanners.py index f9f296753..57c7ecc0d 100644 --- a/gvm/protocols/gmpv208/entities/scanners.py +++ b/gvm/protocols/gmp/requests/v224/_scanners.py @@ -1,23 +1,24 @@ # SPDX-FileCopyrightText: 2021-2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from enum import Enum -from typing import Any, Optional +from typing import Optional, Union -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm._enum import Enum +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class ScannerType(Enum): """Enum for scanner type""" - OSP_SCANNER_TYPE = "1" + # 1 was removed (OSP_SCANNER_TYPE). OPENVAS_SCANNER_TYPE = "2" CVE_SCANNER_TYPE = "3" - GMP_SCANNER_TYPE = "4" # formerly slave scanner GREENBONE_SENSOR_SCANNER_TYPE = "5" @classmethod @@ -35,24 +36,24 @@ def from_string( scanner_type = scanner_type.lower() - if scanner_type == cls.OSP_SCANNER_TYPE.value or scanner_type == "osp": - return cls.OSP_SCANNER_TYPE - if ( scanner_type == cls.OPENVAS_SCANNER_TYPE.value or scanner_type == "openvas" + or scanner_type == "openvas_scanner_type" ): return cls.OPENVAS_SCANNER_TYPE - if scanner_type == cls.CVE_SCANNER_TYPE.value or scanner_type == "cve": + if ( + scanner_type == cls.CVE_SCANNER_TYPE.value + or scanner_type == "cve" + or scanner_type == "cve_scanner_type" + ): return cls.CVE_SCANNER_TYPE - if scanner_type == cls.GMP_SCANNER_TYPE.value or scanner_type == "gmp": - return cls.GMP_SCANNER_TYPE - if ( scanner_type == cls.GREENBONE_SENSOR_SCANNER_TYPE.value or scanner_type == "greenbone" + or scanner_type == "greenbone_sensor_scanner_type" ): return cls.GREENBONE_SENSOR_SCANNER_TYPE @@ -61,141 +62,159 @@ def from_string( ) -class ScannersMixin: - def clone_scanner(self, scanner_id: str) -> Any: - """Clone an existing scanner - - Arguments: - scanner_id: UUID of an existing scanner to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not scanner_id: - raise RequiredArgument( - function=self.clone_scanner.__name__, argument="scanner_id" - ) - - cmd = XmlCommand("create_scanner") - cmd.add_element("copy", scanner_id) - return self._send_xml_command(cmd) - +class Scanners: + @classmethod def create_scanner( - self, + cls, name: str, host: str, - port: int, + port: Union[str, int], scanner_type: ScannerType, credential_id: str, *, ca_pub: Optional[str] = None, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new scanner - Arguments: - name: Name of the scanner - host: The host of the scanner - port: The port of the scanner - scanner_type: Type of the scanner. + Args: + name: Name of the new scanner + host: Hostname or IP address of the scanner + port: Port of the scanner + scanner_type: Type of the scanner credential_id: UUID of client certificate credential for the scanner ca_pub: Certificate of CA to verify scanner certificate comment: Comment for the scanner - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_scanner.__name__, argument="name" + function=cls.create_scanner.__name__, argument="name" ) if not host: raise RequiredArgument( - function=self.create_scanner.__name__, argument="host" + function=cls.create_scanner.__name__, argument="host" ) if not port: raise RequiredArgument( - function=self.create_scanner.__name__, argument="port" + function=cls.create_scanner.__name__, argument="port" ) if not scanner_type: raise RequiredArgument( - function=self.create_scanner.__name__, argument="scanner_type" + function=cls.create_scanner.__name__, argument="scanner_type" ) if not credential_id: raise RequiredArgument( - function=self.create_scanner.__name__, argument="credential_id" - ) - - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.create_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, + function=cls.create_scanner.__name__, argument="credential_id" ) cmd = XmlCommand("create_scanner") cmd.add_element("name", name) cmd.add_element("host", host) cmd.add_element("port", str(port)) + + if not isinstance(scanner_type, ScannerType): + scanner_type = ScannerType(scanner_type) + cmd.add_element("type", scanner_type.value) + cmd.add_element("credential", attrs={"id": str(credential_id)}) + if ca_pub: cmd.add_element("ca_pub", ca_pub) - cmd.add_element("credential", attrs={"id": str(credential_id)}) - if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd - def delete_scanner( - self, scanner_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing scanner - - Arguments: - scanner_id: UUID of the scanner to be deleted. - ultimate: Whether to remove entirely, or to the trashcan. + @classmethod + def modify_scanner( + cls, + scanner_id: EntityID, + *, + name: Optional[str] = None, + host: Optional[str] = None, + port: Optional[int] = None, + scanner_type: Optional[ScannerType] = None, + credential_id: Optional[EntityID] = None, + ca_pub: Optional[str] = None, + comment: Optional[str] = None, + ) -> Request: + """Modify an existing scanner + + Args: + scanner_id: UUID of the scanner to modify + name: New name of the scanner + host: New hostname or IP address of the scanner + port: New port of the scanner + scanner_type: New type of the scanner + credential_id: New UUID of client certificate credential for the + scanner + ca_pub: New certificate of CA to verify scanner certificate + comment: New comment for the scanner """ if not scanner_id: raise RequiredArgument( - function=self.delete_scanner.__name__, argument="scanner_id" + function=cls.modify_scanner.__name__, argument="scanner_id" ) - cmd = XmlCommand("delete_scanner") - cmd.set_attribute("scanner_id", scanner_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) + cmd = XmlCommand("modify_scanner") + cmd.set_attribute("scanner_id", str(scanner_id)) + + if scanner_type is not None: + if not isinstance(scanner_type, ScannerType): + scanner_type = ScannerType(scanner_type) + if not scanner_type: + raise InvalidArgument( + argument="scanner_type", + function=cls.modify_scanner.__name__, + ) + cmd.add_element("type", scanner_type.value) - return self._send_xml_command(cmd) + if host: + cmd.add_element("host", host) + if port: + cmd.add_element("port", str(port)) + + if comment: + cmd.add_element("comment", comment) + + if name: + cmd.add_element("name", name) + + if ca_pub: + cmd.add_element("ca_pub", ca_pub) + + if credential_id: + cmd.add_element("credential", attrs={"id": str(credential_id)}) + + return cmd + + @staticmethod def get_scanners( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of scanners - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan scanners instead - details: Whether to include extra details like tasks using this + details: Whether to include extra details like tasks using this scanner - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_scanners") - - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -203,115 +222,77 @@ def get_scanners( if details is not None: cmd.set_attribute("details", to_bool(details)) - return self._send_xml_command(cmd) + return cmd - def get_scanner(self, scanner_id: str) -> Any: + @classmethod + def get_scanner(cls, scanner_id: EntityID) -> Request: """Request a single scanner - Arguments: + Args: scanner_id: UUID of an existing scanner - - Returns: - The response. See :py:meth:`send_command` for details. """ - cmd = XmlCommand("get_scanners") - if not scanner_id: raise RequiredArgument( - function=self.get_scanner.__name__, argument="scanner_id" + function=cls.get_scanner.__name__, argument="scanner_id" ) - cmd.set_attribute("scanner_id", scanner_id) + cmd = XmlCommand("get_scanners") + cmd.set_attribute("scanner_id", str(scanner_id)) # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) - def modify_scanner( - self, - scanner_id: str, - *, - scanner_type: Optional[ScannerType] = None, - host: Optional[str] = None, - port: Optional[int] = None, - comment: Optional[str] = None, - name: Optional[str] = None, - ca_pub: Optional[str] = None, - credential_id: Optional[str] = None, - ) -> Any: - """Modifies an existing scanner. + return cmd - Arguments: - scanner_id: UUID of scanner to modify. - scanner_type: New type of the Scanner. - host: Host of the scanner. - port: Port of the scanner. - comment: Comment on scanner. - name: Name of scanner. - ca_pub: Certificate of CA to verify scanner's certificate. - credential_id: UUID of the client certificate credential for the - Scanner. - - Returns: - The response. See :py:meth:`send_command` for details. + @classmethod + def verify_scanner(cls, scanner_id: EntityID) -> Request: + """Verify an existing scanner + + Args: + scanner_id: UUID of an existing scanner """ if not scanner_id: raise RequiredArgument( - function=self.modify_scanner.__name__, - argument="scanner_id argument", + function=cls.verify_scanner.__name__, argument="scanner_id" ) - cmd = XmlCommand("modify_scanner") - cmd.set_attribute("scanner_id", scanner_id) - - if scanner_type is not None: - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.modify_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, - ) - - cmd.add_element("type", scanner_type.value) - - if host: - cmd.add_element("host", host) - - if port: - cmd.add_element("port", str(port)) - - if comment: - cmd.add_element("comment", comment) - - if name: - cmd.add_element("name", name) - - if ca_pub: - cmd.add_element("ca_pub", ca_pub) + cmd = XmlCommand("verify_scanner") + cmd.set_attribute("scanner_id", str(scanner_id)) - if credential_id: - cmd.add_element("credential", attrs={"id": str(credential_id)}) + return cmd - return self._send_xml_command(cmd) + @classmethod + def clone_scanner(cls, scanner_id: EntityID) -> Request: + """Clone an existing scanner - def verify_scanner(self, scanner_id: str) -> Any: - """Verify an existing scanner + Args: + scanner_id: UUID of an existing scanner + """ + if not scanner_id: + raise RequiredArgument( + function=cls.clone_scanner.__name__, argument="scanner_id" + ) - Verifies if it is possible to connect to an existing scanner. It is - *not* verified if the scanner works as expected by the user. + cmd = XmlCommand("create_scanner") + cmd.add_element("copy", str(scanner_id)) + return cmd - Arguments: - scanner_id: UUID of the scanner to be verified + @classmethod + def delete_scanner( + cls, scanner_id: EntityID, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing scanner - Returns: - The response. See :py:meth:`send_command` for details. + Args: + scanner_id: UUID of an existing scanner """ if not scanner_id: raise RequiredArgument( - function=self.verify_scanner.__name__, argument="scanner_id" + function=cls.delete_scanner.__name__, argument="scanner_id" ) - cmd = XmlCommand("verify_scanner") - cmd.set_attribute("scanner_id", scanner_id) + cmd = XmlCommand("delete_scanner") + cmd.set_attribute("scanner_id", str(scanner_id)) + cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/schedules.py b/gvm/protocols/gmp/requests/v224/_schedules.py similarity index 68% rename from gvm/protocols/gmpv208/entities/schedules.py rename to gvm/protocols/gmp/requests/v224/_schedules.py index 0a15a6617..6dbb6b8e3 100644 --- a/gvm/protocols/gmpv208/entities/schedules.py +++ b/gvm/protocols/gmp/requests/v224/_schedules.py @@ -1,42 +1,44 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + + +class Schedules: -class SchedulesMixin: - def clone_schedule(self, schedule_id: str) -> Any: + @classmethod + def clone_schedule(cls, schedule_id: EntityID) -> Request: """Clone an existing schedule - Arguments: + Args: schedule_id: UUID of an existing schedule to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not schedule_id: raise RequiredArgument( - function=self.clone_schedule.__name__, argument="schedule_id" + function=cls.clone_schedule.__name__, argument="schedule_id" ) cmd = XmlCommand("create_schedule") - cmd.add_element("copy", schedule_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(schedule_id)) + return cmd + @classmethod def create_schedule( - self, + cls, name: str, icalendar: str, timezone: str, *, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new schedule based in `iCalendar`_ data. Example: @@ -61,38 +63,38 @@ def create_schedule( cal.add_component(event) - gmp.create_schedule( + Schedules.create_schedule( name="My Schedule", icalendar=cal.to_ical(), timezone='UTC' ) - Arguments: + + Args: name: Name of the new schedule icalendar: `iCalendar`_ (RFC 5545) based data. - timezone: Timezone to use for the icalender events e.g + timezone: Timezone to use for the icalendar events e.g Europe/Berlin. If the datetime values in the icalendar data are missing timezone information this timezone gets applied. Otherwise the datetime values from the icalendar data are displayed in this timezone comment: Comment on schedule. - Returns: - The response. See :py:meth:`send_command` for details. - .. _iCalendar: https://tools.ietf.org/html/rfc5545 """ if not name: raise RequiredArgument( - function=self.create_schedule.__name__, argument="name" + function=cls.create_schedule.__name__, argument="name" ) + if not icalendar: raise RequiredArgument( - function=self.create_schedule.__name__, argument="icalendar" + function=cls.create_schedule.__name__, argument="icalendar" ) + if not timezone: raise RequiredArgument( - function=self.create_schedule.__name__, argument="timezone" + function=cls.create_schedule.__name__, argument="timezone" ) cmd = XmlCommand("create_schedule") @@ -104,50 +106,48 @@ def create_schedule( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_schedule( - self, schedule_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, schedule_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing schedule - Arguments: + Args: schedule_id: UUID of the schedule to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not schedule_id: raise RequiredArgument( - function=self.delete_schedule.__name__, argument="schedule_id" + function=cls.delete_schedule.__name__, argument="schedule_id" ) cmd = XmlCommand("delete_schedule") - cmd.set_attribute("schedule_id", schedule_id) + cmd.set_attribute("schedule_id", str(schedule_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_schedules( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, tasks: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of schedules - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan schedules instead tasks: Whether to include tasks using the schedules - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_schedules") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -155,69 +155,65 @@ def get_schedules( if tasks is not None: cmd.set_attribute("tasks", to_bool(tasks)) - return self._send_xml_command(cmd) + return cmd + @classmethod def get_schedule( - self, schedule_id: str, *, tasks: Optional[bool] = None - ) -> Any: + cls, schedule_id: EntityID, *, tasks: Optional[bool] = None + ) -> Request: """Request a single schedule - Arguments: + Args: schedule_id: UUID of an existing schedule tasks: Whether to include tasks using the schedules - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_schedules") if not schedule_id: raise RequiredArgument( - function=self.get_schedule.__name__, argument="schedule_id" + function=cls.get_schedule.__name__, argument="schedule_id" ) - cmd.set_attribute("schedule_id", schedule_id) + cmd.set_attribute("schedule_id", str(schedule_id)) if tasks is not None: cmd.set_attribute("tasks", to_bool(tasks)) - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_schedule( - self, - schedule_id: str, + cls, + schedule_id: EntityID, *, name: Optional[str] = None, icalendar: Optional[str] = None, timezone: Optional[str] = None, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies an existing schedule - Arguments: + Args: schedule_id: UUID of the schedule to be modified name: Name of the schedule icalendar: `iCalendar`_ (RFC 5545) based data. - timezone: Timezone to use for the icalender events e.g + timezone: Timezone to use for the icalendar events e.g Europe/Berlin. If the datetime values in the icalendar data are missing timezone information this timezone gets applied. Otherwise the datetime values from the icalendar data are displayed in this timezone comment: Comment on schedule. - Returns: - The response. See :py:meth:`send_command` for details. - .. _iCalendar: https://tools.ietf.org/html/rfc5545 """ if not schedule_id: raise RequiredArgument( - function=self.modify_schedule.__name__, argument="schedule_id" + function=cls.modify_schedule.__name__, argument="schedule_id" ) cmd = XmlCommand("modify_schedule") - cmd.set_attribute("schedule_id", schedule_id) + cmd.set_attribute("schedule_id", str(schedule_id)) if name: cmd.add_element("name", name) @@ -231,4 +227,4 @@ def modify_schedule( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_secinfo.py b/gvm/protocols/gmp/requests/v224/_secinfo.py new file mode 100644 index 000000000..83566862e --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_secinfo.py @@ -0,0 +1,100 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm._enum import Enum +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class InfoType(Enum): + """Enum for info types""" + + CERT_BUND_ADV = "CERT_BUND_ADV" + CPE = "CPE" + CVE = "CVE" + DFN_CERT_ADV = "DFN_CERT_ADV" + OVALDEF = "OVALDEF" + NVT = "NVT" + + +class SecInfo: + @classmethod + def get_info(cls, info_id: EntityID, info_type: InfoType) -> Request: + """Request a single secinfo + + Arguments: + info_id: ID of an existing secinfo + info_type: Type must be either CERT_BUND_ADV, CPE, CVE, + DFN_CERT_ADV, OVALDEF, NVT + """ + if not info_type: + raise RequiredArgument( + function=cls.get_info.__name__, argument="info_type" + ) + + if not isinstance(info_type, InfoType): + info_type = InfoType(info_type) + + if not info_id: + raise RequiredArgument( + function=cls.get_info.__name__, argument="info_id" + ) + + cmd = XmlCommand("get_info") + cmd.set_attribute("info_id", str(info_id)) + + cmd.set_attribute("type", info_type.value) + + # for single entity always request all details + cmd.set_attribute("details", "1") + return cmd + + @classmethod + def get_info_list( + cls, + info_type: InfoType, + *, + filter_string: Optional[str] = None, + filter_id: Optional[str] = None, + name: Optional[str] = None, + details: Optional[bool] = None, + ) -> Request: + """Request a list of security information + + Args: + info_type: Type must be either CERT_BUND_ADV, CPE, CVE, + DFN_CERT_ADV, OVALDEF or NVT + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + name: Name or identifier of the requested information + details: Whether to include information about references to this + information + """ + if not info_type: + raise RequiredArgument( + function=cls.get_info_list.__name__, argument="info_type" + ) + + if not isinstance(info_type, InfoType): + info_type = InfoType(info_type) + + cmd = XmlCommand("get_info") + + cmd.set_attribute("type", info_type.value) + + cmd.add_filter(filter_string, filter_id) + + if name: + cmd.set_attribute("name", name) + + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + return cmd diff --git a/gvm/protocols/gmpv208/entities/severity.py b/gvm/protocols/gmp/requests/v224/_severity.py similarity index 100% rename from gvm/protocols/gmpv208/entities/severity.py rename to gvm/protocols/gmp/requests/v224/_severity.py diff --git a/gvm/protocols/gmpv208/system/system_reports.py b/gvm/protocols/gmp/requests/v224/_system_reports.py similarity index 77% rename from gvm/protocols/gmpv208/system/system_reports.py rename to gvm/protocols/gmp/requests/v224/_system_reports.py index 181e457f9..415d1e39c 100644 --- a/gvm/protocols/gmpv208/system/system_reports.py +++ b/gvm/protocols/gmp/requests/v224/_system_reports.py @@ -3,27 +3,29 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -# pylint: disable=arguments-differ, redefined-builtin, too-many-lines - from numbers import Integral -from typing import Any, Optional +from typing import Optional from gvm.errors import InvalidArgument +from gvm.protocols.core import Request from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + -class SystemReportsMixin: +class SystemReports: + @classmethod def get_system_reports( - self, + cls, *, name: Optional[str] = None, duration: Optional[int] = None, start_time: Optional[str] = None, end_time: Optional[str] = None, brief: Optional[bool] = None, - slave_id: Optional[str] = None, - ) -> Any: + slave_id: Optional[EntityID] = None, + ) -> Request: """Request a list of system reports Arguments: @@ -36,9 +38,6 @@ def get_system_reports( include in ISO time format brief: Whether to include the actual system reports slave_id: UUID of GMP scanner from which to get the system reports - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_system_reports") @@ -47,7 +46,10 @@ def get_system_reports( if duration is not None: if not isinstance(duration, Integral): - raise InvalidArgument("duration needs to be an integer number") + raise InvalidArgument( + "duration needs to be an integer number", + function=cls.get_system_reports.__name__, + ) cmd.set_attribute("duration", str(duration)) @@ -61,6 +63,6 @@ def get_system_reports( cmd.set_attribute("brief", to_bool(brief)) if slave_id: - cmd.set_attribute("slave_id", slave_id) + cmd.set_attribute("slave_id", str(slave_id)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/tags.py b/gvm/protocols/gmp/requests/v224/_tags.py similarity index 59% rename from gvm/protocols/gmpv208/entities/tags.py rename to gvm/protocols/gmp/requests/v224/_tags.py index cc45c462d..ddb600779 100644 --- a/gvm/protocols/gmpv208/entities/tags.py +++ b/gvm/protocols/gmp/requests/v224/_tags.py @@ -1,49 +1,51 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, List, Optional +from typing import Optional -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.utils import add_filter, to_bool +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._entity_type import EntityType + -class TagsMixin: - def clone_tag(self, tag_id: str) -> Any: +class Tags: + + @classmethod + def clone_tag(cls, tag_id: EntityID) -> Request: """Clone an existing tag - Arguments: + Args: tag_id: UUID of an existing tag to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not tag_id: raise RequiredArgument( - function=self.clone_tag.__name__, argument="tag_id" + function=cls.clone_tag.__name__, argument="tag_id" ) cmd = XmlCommand("create_tag") - cmd.add_element("copy", tag_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(tag_id)) + return cmd + @classmethod def create_tag( - self, + cls, name: str, resource_type: EntityType, *, resource_filter: Optional[str] = None, - resource_ids: Optional[List[str]] = None, + resource_ids: Optional[list[EntityID]] = None, value: Optional[str] = None, comment: Optional[str] = None, active: Optional[bool] = None, - ) -> Any: - """Create a tag. + ) -> Request: + """Create a tag - Arguments: + Args: name: Name of the tag. A full tag name consisting of namespace and predicate e.g. `foo:bar`. resource_type: Entity type the tag is to be attached to. @@ -55,52 +57,45 @@ def create_tag( value: Value associated with the tag. comment: Comment for the tag. active: Whether the tag should be active. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_tag.__name__, argument="name" + function=cls.create_tag.__name__, argument="name" ) if resource_filter and resource_ids: raise InvalidArgument( "create_tag accepts either resource_filter or resource_ids " "argument", - function=self.create_tag.__name__, + function=cls.create_tag.__name__, ) if not resource_type: raise RequiredArgument( - function=self.create_tag.__name__, argument="resource_type" + function=cls.create_tag.__name__, argument="resource_type" ) if not isinstance(resource_type, EntityType): - raise InvalidArgumentType( - function=self.create_tag.__name__, - argument="resource_type", - arg_type=EntityType.__name__, - ) + resource_type = EntityType(resource_type) cmd = XmlCommand("create_tag") cmd.add_element("name", name) - _xmlresources = cmd.add_element("resources") + xml_resources = cmd.add_element("resources") if resource_filter is not None: - _xmlresources.set_attribute("filter", resource_filter) + xml_resources.set_attribute("filter", resource_filter) for resource_id in resource_ids or []: - _xmlresources.add_element( + xml_resources.add_element( "resource", attrs={"id": str(resource_id)} ) - _actual_resource_type = resource_type + actual_resource_type = resource_type if resource_type.value == EntityType.AUDIT.value: - _actual_resource_type = EntityType.TASK + actual_resource_type = EntityType.TASK elif resource_type.value == EntityType.POLICY.value: - _actual_resource_type = EntityType.SCAN_CONFIG - _xmlresources.add_element("type", _actual_resource_type.value) + actual_resource_type = EntityType.SCAN_CONFIG + xml_resources.add_element("type", actual_resource_type.value) if comment: cmd.add_element("comment", comment) @@ -109,55 +104,50 @@ def create_tag( cmd.add_element("value", value) if active is not None: - if active: - cmd.add_element("active", "1") - else: - cmd.add_element("active", "0") + cmd.add_element("active", to_bool(active)) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_tag( - self, tag_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, tag_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing tag - Arguments: + Args: tag_id: UUID of the tag to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not tag_id: raise RequiredArgument( - function=self.delete_tag.__name__, argument="tag_id" + function=cls.delete_tag.__name__, argument="tag_id" ) cmd = XmlCommand("delete_tag") - cmd.set_attribute("tag_id", tag_id) + cmd.set_attribute("tag_id", str(tag_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_tags( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, names_only: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of tags - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get tags from the trashcan instead names_only: Whether to get only distinct tag names - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_tags") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -165,43 +155,42 @@ def get_tags( if names_only is not None: cmd.set_attribute("names_only", to_bool(names_only)) - return self._send_xml_command(cmd) + return cmd - def get_tag(self, tag_id: str) -> Any: + @classmethod + def get_tag(cls, tag_id: EntityID) -> Request: """Request a single tag - Arguments: + Args: tag_id: UUID of an existing tag - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_tags") if not tag_id: raise RequiredArgument( - function=self.get_tag.__name__, argument="tag_id" + function=cls.get_tag.__name__, argument="tag_id" ) - cmd.set_attribute("tag_id", tag_id) - return self._send_xml_command(cmd) + cmd.set_attribute("tag_id", str(tag_id)) + return cmd + @classmethod def modify_tag( - self, - tag_id: str, + cls, + tag_id: EntityID, *, comment: Optional[str] = None, name: Optional[str] = None, - value=None, - active=None, + value: Optional[str] = None, + active: Optional[bool] = None, resource_action: Optional[str] = None, resource_type: Optional[EntityType] = None, resource_filter: Optional[str] = None, - resource_ids: Optional[List[str]] = None, - ) -> Any: + resource_ids: Optional[list[EntityID]] = None, + ) -> Request: """Modifies an existing tag. - Arguments: + Args: tag_id: UUID of the tag. comment: Comment to add to the tag. name: Name of the tag. @@ -214,13 +203,10 @@ def modify_tag( resource_filter: Filter term to select resources the tag is to be attached to. resource_ids: IDs of the resources to which to attach the tag. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not tag_id: raise RequiredArgument( - function=self.modify_tag.__name__, argument="tag_id" + function=cls.modify_tag.__name__, argument="tag_id" ) cmd = XmlCommand("modify_tag") @@ -241,33 +227,30 @@ def modify_tag( if resource_action or resource_filter or resource_ids or resource_type: if resource_filter and not resource_type: raise RequiredArgument( - function=self.modify_tag.__name__, argument="resource_type" + function=cls.modify_tag.__name__, argument="resource_type" ) - _xmlresources = cmd.add_element("resources") + xml_resources = cmd.add_element("resources") if resource_action is not None: - _xmlresources.set_attribute("action", resource_action) + xml_resources.set_attribute("action", resource_action) if resource_filter is not None: - _xmlresources.set_attribute("filter", resource_filter) + xml_resources.set_attribute("filter", resource_filter) for resource_id in resource_ids or []: - _xmlresources.add_element( + xml_resources.add_element( "resource", attrs={"id": str(resource_id)} ) if resource_type is not None: if not isinstance(resource_type, EntityType): - raise InvalidArgumentType( - function=self.modify_tag.__name__, - argument="resource_type", - arg_type=EntityType.__name__, - ) - _actual_resource_type = resource_type + resource_type = EntityType(resource_type) + + actual_resource_type = resource_type if resource_type.value == EntityType.AUDIT.value: - _actual_resource_type = EntityType.TASK + actual_resource_type = EntityType.TASK elif resource_type.value == EntityType.POLICY.value: - _actual_resource_type = EntityType.SCAN_CONFIG - _xmlresources.add_element("type", _actual_resource_type.value) + actual_resource_type = EntityType.SCAN_CONFIG + xml_resources.add_element("type", actual_resource_type.value) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/targets.py b/gvm/protocols/gmp/requests/v224/_targets.py similarity index 59% rename from gvm/protocols/gmpv208/entities/targets.py rename to gvm/protocols/gmp/requests/v224/_targets.py index bab3b73f6..4c745fb2a 100644 --- a/gvm/protocols/gmpv208/entities/targets.py +++ b/gvm/protocols/gmp/requests/v224/_targets.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from enum import Enum -from typing import Any, List, Optional +from typing import Optional, Union -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool, to_comma_list +from gvm._enum import Enum +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID + class AliveTest(Enum): """Enum for choosing an alive test""" @@ -54,47 +56,31 @@ def from_string( ) from None -class TargetsMixin: - def clone_target(self, target_id: str) -> Any: - """Clone an existing target - - Arguments: - target_id: UUID of an existing target to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not target_id: - raise RequiredArgument( - function=self.clone_target.__name__, argument="target_id" - ) - - cmd = XmlCommand("create_target") - cmd.add_element("copy", target_id) - return self._send_xml_command(cmd) - +class Targets: + @classmethod def create_target( - self, + cls, name: str, *, asset_hosts_filter: Optional[str] = None, - hosts: Optional[List[str]] = None, + hosts: Optional[list[str]] = None, comment: Optional[str] = None, - exclude_hosts: Optional[List[str]] = None, - ssh_credential_id: Optional[str] = None, - ssh_credential_port: Optional[int] = None, - smb_credential_id: Optional[str] = None, - esxi_credential_id: Optional[str] = None, - snmp_credential_id: Optional[str] = None, - alive_test: Optional[AliveTest] = None, + exclude_hosts: Optional[list[str]] = None, + ssh_credential_id: Optional[EntityID] = None, + ssh_credential_port: Optional[Union[int, str]] = None, + smb_credential_id: Optional[EntityID] = None, + esxi_credential_id: Optional[EntityID] = None, + snmp_credential_id: Optional[EntityID] = None, + alive_test: Optional[Union[str, AliveTest]] = None, + allow_simultaneous_ips: Optional[bool] = None, reverse_lookup_only: Optional[bool] = None, reverse_lookup_unify: Optional[bool] = None, port_range: Optional[str] = None, - port_list_id: Optional[str] = None, - ) -> Any: + port_list_id: Optional[EntityID] = None, + ) -> Request: """Create a new target - Arguments: + Args: name: Name of the target asset_hosts_filter: Filter to select target host from assets hosts hosts: List of hosts addresses to scan @@ -106,24 +92,22 @@ def create_target( snmp_credential_id: UUID of a snmp credential to use on target esxi_credential_id: UUID of a esxi credential to use on target alive_test: Which alive test to use + allow_simultaneous_ips: Whether to scan multiple IPs of the + same host simultaneously reverse_lookup_only: Whether to scan only hosts that have names reverse_lookup_unify: Whether to scan only one IP when multiple IPs have the same name. port_range: Port range for the target port_list_id: UUID of the port list to use on target - - Returns: - The response. See :py:meth:`send_command` for details. """ - - cmd = XmlCommand("create_target") - cmd.add_element("name", name) - if not name: raise RequiredArgument( - function=self.create_target.__name__, argument="name" + function=cls.create_target.__name__, argument="name" ) + cmd = XmlCommand("create_target") + cmd.add_element("name", name) + if asset_hosts_filter: cmd.add_element( "asset_hosts", attrs={"filter": str(asset_hosts_filter)} @@ -132,7 +116,7 @@ def create_target( cmd.add_element("hosts", to_comma_list(hosts)) else: raise RequiredArgument( - function=self.create_target.__name__, + function=cls.create_target.__name__, argument="hosts or asset_hosts_filter", ) @@ -143,31 +127,37 @@ def create_target( cmd.add_element("exclude_hosts", to_comma_list(exclude_hosts)) if ssh_credential_id: - _xmlssh = cmd.add_element( - "ssh_credential", attrs={"id": ssh_credential_id} + xml_ssh = cmd.add_element( + "ssh_credential", attrs={"id": str(ssh_credential_id)} ) if ssh_credential_port: - _xmlssh.add_element("port", str(ssh_credential_port)) + xml_ssh.add_element("port", str(ssh_credential_port)) if smb_credential_id: - cmd.add_element("smb_credential", attrs={"id": smb_credential_id}) + cmd.add_element( + "smb_credential", attrs={"id": str(smb_credential_id)} + ) if esxi_credential_id: - cmd.add_element("esxi_credential", attrs={"id": esxi_credential_id}) + cmd.add_element( + "esxi_credential", attrs={"id": str(esxi_credential_id)} + ) if snmp_credential_id: - cmd.add_element("snmp_credential", attrs={"id": snmp_credential_id}) + cmd.add_element( + "snmp_credential", attrs={"id": str(snmp_credential_id)} + ) if alive_test: if not isinstance(alive_test, AliveTest): - raise InvalidArgumentType( - function=self.create_target.__name__, - argument="alive_test", - arg_type=AliveTest.__name__, - ) - + alive_test = AliveTest(alive_test) cmd.add_element("alive_tests", alive_test.value) + if allow_simultaneous_ips is not None: + cmd.add_element( + "allow_simultaneous_ips", to_bool(allow_simultaneous_ips) + ) + if reverse_lookup_only is not None: cmd.add_element("reverse_lookup_only", to_bool(reverse_lookup_only)) @@ -176,120 +166,38 @@ def create_target( "reverse_lookup_unify", to_bool(reverse_lookup_unify) ) - # since 20.08 one of port_range or port_list_id is required! - if not port_range and not port_list_id: - raise RequiredArgument( - function=self.create_target.__name__, - argument="port_range or port_list_id", - ) - if port_range: cmd.add_element("port_range", port_range) if port_list_id: - cmd.add_element("port_list", attrs={"id": port_list_id}) - - return self._send_xml_command(cmd) - - def delete_target( - self, target_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing target - - Arguments: - target_id: UUID of the target to be deleted. - ultimate: Whether to remove entirely, or to the trashcan. - """ - if not target_id: - raise RequiredArgument( - function=self.delete_target.__name__, argument="target_id" - ) - - cmd = XmlCommand("delete_target") - cmd.set_attribute("target_id", target_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) - - return self._send_xml_command(cmd) - - def get_target( - self, target_id: str, *, tasks: Optional[bool] = None - ) -> Any: - """Request a single target - - Arguments: - target_id: UUID of an existing target - tasks: Whether to include list of tasks that use the target - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_targets") - - if not target_id: - raise RequiredArgument( - function=self.get_target.__name__, argument="target_id" - ) - - cmd.set_attribute("target_id", target_id) - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - return self._send_xml_command(cmd) - - def get_targets( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - trash: Optional[bool] = None, - tasks: Optional[bool] = None, - ) -> Any: - """Request a list of targets - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - trash: Whether to get the trashcan targets instead - tasks: Whether to include list of tasks that use the target - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_targets") + cmd.add_element("port_list", attrs={"id": str(port_list_id)}) - add_filter(cmd, filter_string, filter_id) - - if trash is not None: - cmd.set_attribute("trash", to_bool(trash)) - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_target( - self, - target_id: str, + cls, + target_id: EntityID, *, name: Optional[str] = None, comment: Optional[str] = None, - hosts: Optional[List[str]] = None, - exclude_hosts: Optional[List[str]] = None, - ssh_credential_id: Optional[str] = None, - ssh_credential_port: Optional[bool] = None, - smb_credential_id: Optional[str] = None, - esxi_credential_id: Optional[str] = None, - snmp_credential_id: Optional[str] = None, - alive_test: Optional[AliveTest] = None, + hosts: Optional[list[str]] = None, + exclude_hosts: Optional[list[str]] = None, + ssh_credential_id: Optional[EntityID] = None, + ssh_credential_port: Optional[Union[str, int]] = None, + smb_credential_id: Optional[EntityID] = None, + esxi_credential_id: Optional[EntityID] = None, + snmp_credential_id: Optional[EntityID] = None, + alive_test: Optional[Union[AliveTest, str]] = None, + allow_simultaneous_ips: Optional[bool] = None, reverse_lookup_only: Optional[bool] = None, reverse_lookup_unify: Optional[bool] = None, - port_list_id: Optional[str] = None, - ) -> Any: - """Modifies an existing target. + port_list_id: Optional[EntityID] = None, + ) -> Request: + """Modify an existing target. - Arguments: - target_id: ID of target to modify. + Args: + target_id: UUID of target to modify. comment: Comment on target. name: Name of target. hosts: List of target hosts. @@ -301,20 +209,19 @@ def modify_target( snmp_credential_id: UUID of SNMP credential to use on target. port_list_id: UUID of port list describing ports to scan. alive_test: Which alive tests to use. + allow_simultaneous_ips: Whether to scan multiple IPs of the + same host simultaneously reverse_lookup_only: Whether to scan only hosts that have names. reverse_lookup_unify: Whether to scan only one IP when multiple IPs have the same name. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not target_id: raise RequiredArgument( - function=self.modify_target.__name__, argument="target_id" + function=cls.modify_target.__name__, argument="target_id" ) cmd = XmlCommand("modify_target") - cmd.set_attribute("target_id", target_id) + cmd.set_attribute("target_id", str(target_id)) if comment: cmd.add_element("comment", comment) @@ -332,29 +239,36 @@ def modify_target( if alive_test: if not isinstance(alive_test, AliveTest): - raise InvalidArgumentType( - function=self.modify_target.__name__, - argument="alive_test", - arg_type=AliveTest.__name__, - ) + alive_test = AliveTest(alive_test) cmd.add_element("alive_tests", alive_test.value) if ssh_credential_id: - _xmlssh = cmd.add_element( - "ssh_credential", attrs={"id": ssh_credential_id} + xml_ssh = cmd.add_element( + "ssh_credential", attrs={"id": str(ssh_credential_id)} ) if ssh_credential_port: - _xmlssh.add_element("port", str(ssh_credential_port)) + xml_ssh.add_element("port", str(ssh_credential_port)) if smb_credential_id: - cmd.add_element("smb_credential", attrs={"id": smb_credential_id}) + cmd.add_element( + "smb_credential", attrs={"id": str(smb_credential_id)} + ) if esxi_credential_id: - cmd.add_element("esxi_credential", attrs={"id": esxi_credential_id}) + cmd.add_element( + "esxi_credential", attrs={"id": str(esxi_credential_id)} + ) if snmp_credential_id: - cmd.add_element("snmp_credential", attrs={"id": snmp_credential_id}) + cmd.add_element( + "snmp_credential", attrs={"id": str(snmp_credential_id)} + ) + + if allow_simultaneous_ips is not None: + cmd.add_element( + "allow_simultaneous_ips", to_bool(allow_simultaneous_ips) + ) if reverse_lookup_only is not None: cmd.add_element("reverse_lookup_only", to_bool(reverse_lookup_only)) @@ -365,6 +279,93 @@ def modify_target( ) if port_list_id: - cmd.add_element("port_list", attrs={"id": port_list_id}) + cmd.add_element("port_list", attrs={"id": str(port_list_id)}) + + return cmd + + @classmethod + def clone_target(cls, target_id: EntityID) -> Request: + """Clone an existing target. + + Args: + target_id: UUID of an existing target to clone. + """ + if not target_id: + raise RequiredArgument( + function=cls.clone_target.__name__, argument="target_id" + ) + + cmd = XmlCommand("create_target") + cmd.add_element("copy", str(target_id)) + return cmd + + @classmethod + def delete_target( + cls, target_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: + """Delete an existing target. + + Args: + target_id: UUID of an existing target to delete. + ultimate: Whether to remove entirely or to the trashcan. + """ + if not target_id: + raise RequiredArgument( + function=cls.delete_target.__name__, argument="target_id" + ) + + cmd = XmlCommand("delete_target") + cmd.set_attribute("target_id", str(target_id)) + cmd.set_attribute("ultimate", to_bool(ultimate)) + return cmd + + @classmethod + def get_target( + cls, target_id: EntityID, *, tasks: Optional[bool] = None + ) -> Request: + """Request a single target. + + Args: + target_id: UUID of the target to request. + tasks: Whether to include list of tasks that use the target + """ + if not target_id: + raise RequiredArgument( + function=cls.get_target.__name__, argument="target_id" + ) + + cmd = XmlCommand("get_targets") + cmd.set_attribute("target_id", str(target_id)) + + if tasks is not None: + cmd.set_attribute("tasks", to_bool(tasks)) + + return cmd + + @classmethod + def get_targets( + cls, + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + trash: Optional[bool] = None, + tasks: Optional[bool] = None, + ) -> Request: + """Request a list of targets. + + Args: + filter_string: Filter term to use for the query. + filter_id: UUID of an existing filter to use for the query. + trash: Whether to include targets in the trashcan. + tasks: Whether to include list of tasks that use the target. + """ + cmd = XmlCommand("get_targets") + cmd.add_filter(filter_string, filter_id) + + if trash is not None: + cmd.set_attribute("trash", to_bool(trash)) + + if tasks is not None: + cmd.set_attribute("tasks", to_bool(tasks)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/tasks.py b/gvm/protocols/gmp/requests/v224/_tasks.py similarity index 53% rename from gvm/protocols/gmpv208/entities/tasks.py rename to gvm/protocols/gmp/requests/v224/_tasks.py index b3c1fb584..9adeb8dbc 100644 --- a/gvm/protocols/gmpv208/entities/tasks.py +++ b/gvm/protocols/gmp/requests/v224/_tasks.py @@ -1,55 +1,53 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from collections.abc import Mapping from numbers import Integral -from typing import Any, List, Optional +from typing import Mapping, Optional, Sequence -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering -from gvm.utils import add_filter, is_list_like, to_bool, to_comma_list +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import SupportsStr, to_bool, to_comma_list from gvm.xml import XmlCommand +from .._entity_id import EntityID +from ._hosts import HostsOrdering + + +class Tasks: -class TasksMixin: - def clone_task(self, task_id: str) -> Any: + @classmethod + def clone_task(cls, task_id: EntityID) -> Request: """Clone an existing task - Arguments: + Args: task_id: UUID of existing task to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.clone_task.__name__, argument="task_id" + function=cls.clone_task.__name__, argument="task_id" ) cmd = XmlCommand("create_task") - cmd.add_element("copy", task_id) - return self._send_xml_command(cmd) + cmd.add_element("copy", str(task_id)) + return cmd + @classmethod def create_container_task( - self, name: str, *, comment: Optional[str] = None - ) -> Any: + cls, name: str, *, comment: Optional[str] = None + ) -> Request: """Create a new container task A container task is a "meta" task to import and view reports from other systems. - Arguments: + Args: name: Name of the task comment: Comment for the task - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_container_task.__name__, argument="name" + function=cls.create_container_task.__name__, argument="name" ) cmd = XmlCommand("create_task") @@ -59,27 +57,28 @@ def create_container_task( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def create_task( - self, + cls, name: str, - config_id: str, - target_id: str, - scanner_id: str, + config_id: EntityID, + target_id: EntityID, + scanner_id: EntityID, *, alterable: Optional[bool] = None, hosts_ordering: Optional[HostsOrdering] = None, - schedule_id: Optional[str] = None, - alert_ids: Optional[List[str]] = None, + schedule_id: Optional[EntityID] = None, + alert_ids: Optional[Sequence[EntityID]] = None, comment: Optional[str] = None, schedule_periods: Optional[int] = None, - observers: Optional[List[str]] = None, - preferences: Optional[dict] = None, - ) -> Any: + observers: Optional[Sequence[str]] = None, + preferences: Optional[Mapping[str, SupportsStr]] = None, + ) -> Request: """Create a new scan task - Arguments: + Args: name: Name of the new task config_id: UUID of config to use by the task target_id: UUID of target to be scanned @@ -94,42 +93,39 @@ def create_task( observers: List of names or ids of users which should be allowed to observe this task preferences: Name/Value pairs of scanner preferences. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_task.__name__, argument="name" + function=cls.create_task.__name__, argument="name" ) if not config_id: raise RequiredArgument( - function=self.create_task.__name__, argument="config_id" + function=cls.create_task.__name__, argument="config_id" ) if not target_id: raise RequiredArgument( - function=self.create_task.__name__, argument="target_id" + function=cls.create_task.__name__, argument="target_id" ) if not scanner_id: raise RequiredArgument( - function=self.create_task.__name__, argument="scanner_id" + function=cls.create_task.__name__, argument="scanner_id" ) # don't allow to create a container task with create_task if target_id == "0": raise InvalidArgument( - function=self.create_task.__name__, argument="target_id" + function=cls.create_task.__name__, argument="target_id" ) cmd = XmlCommand("create_task") cmd.add_element("name", name) cmd.add_element("usage_type", "scan") - cmd.add_element("config", attrs={"id": config_id}) - cmd.add_element("target", attrs={"id": target_id}) - cmd.add_element("scanner", attrs={"id": scanner_id}) + cmd.add_element("config", attrs={"id": str(config_id)}) + cmd.add_element("target", attrs={"id": str(target_id)}) + cmd.add_element("scanner", attrs={"id": str(scanner_id)}) if comment: cmd.add_element("comment", comment) @@ -139,27 +135,15 @@ def create_task( if hosts_ordering: if not isinstance(hosts_ordering, HostsOrdering): - raise InvalidArgumentType( - function=self.create_task.__name__, - argument="hosts_ordering", - arg_type=HostsOrdering.__name__, - ) + hosts_ordering = HostsOrdering(hosts_ordering) cmd.add_element("hosts_ordering", hosts_ordering.value) - if alert_ids is not None: - if not is_list_like(alert_ids): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="alert_ids", - arg_type="list", - ) - - if not len(alert_ids) == 0: - for alert in alert_ids: - cmd.add_element("alert", attrs={"id": str(alert)}) + if alert_ids: + for alert in alert_ids: + cmd.add_element("alert", attrs={"id": str(alert)}) if schedule_id: - cmd.add_element("schedule", attrs={"id": schedule_id}) + cmd.add_element("schedule", attrs={"id": str(schedule_id)}) if schedule_periods is not None: if ( @@ -172,81 +156,65 @@ def create_task( ) cmd.add_element("schedule_periods", str(schedule_periods)) - if observers is not None: - if not is_list_like(observers): - raise InvalidArgumentType( - function=self.create_task.__name__, - argument="observers", - arg_type="list", - ) - + if observers: # gvmd splits by comma and space # gvmd tries to lookup each value as user name and afterwards as # user id. So both user name and user id are possible cmd.add_element("observers", to_comma_list(observers)) if preferences is not None: - if not isinstance(preferences, Mapping): - raise InvalidArgumentType( - function=self.create_task.__name__, - argument="preferences", - arg_type=Mapping.__name__, - ) - - _xmlprefs = cmd.add_element("preferences") + xml_prefs = cmd.add_element("preferences") for pref_name, pref_value in preferences.items(): - _xmlpref = _xmlprefs.add_element("preference") - _xmlpref.add_element("scanner_name", pref_name) - _xmlpref.add_element("value", str(pref_value)) + xml_pref = xml_prefs.add_element("preference") + xml_pref.add_element("scanner_name", pref_name) + xml_pref.add_element("value", str(pref_value)) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_task( - self, task_id: str, *, ultimate: Optional[bool] = False - ) -> Any: + cls, task_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing task - Arguments: + Args: task_id: UUID of the task to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not task_id: raise RequiredArgument( - function=self.delete_task.__name__, argument="task_id" + function=cls.delete_task.__name__, argument="task_id" ) cmd = XmlCommand("delete_task") - cmd.set_attribute("task_id", task_id) + cmd.set_attribute("task_id", str(task_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_tasks( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, trash: Optional[bool] = None, details: Optional[bool] = None, schedules_only: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of tasks - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: Whether to get the trashcan tasks instead details: Whether to include full task details schedules_only: Whether to only include id, name and schedule details - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_tasks") cmd.set_attribute("usage_type", "scan") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) @@ -257,50 +225,49 @@ def get_tasks( if schedules_only is not None: cmd.set_attribute("schedules_only", to_bool(schedules_only)) - return self._send_xml_command(cmd) + return cmd - def get_task(self, task_id: str) -> Any: + @classmethod + def get_task(cls, task_id: EntityID) -> Request: """Request a single task - Arguments: + Args: task_id: UUID of an existing task - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.get_task.__name__, argument="task_id" + function=cls.get_task.__name__, argument="task_id" ) cmd = XmlCommand("get_tasks") - cmd.set_attribute("task_id", task_id) + cmd.set_attribute("task_id", str(task_id)) cmd.set_attribute("usage_type", "scan") # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_task( - self, - task_id: str, + cls, + task_id: EntityID, *, name: Optional[str] = None, - config_id: Optional[str] = None, - target_id: Optional[str] = None, - scanner_id: Optional[str] = None, + config_id: Optional[EntityID] = None, + target_id: Optional[EntityID] = None, + scanner_id: Optional[EntityID] = None, alterable: Optional[bool] = None, hosts_ordering: Optional[HostsOrdering] = None, - schedule_id: Optional[str] = None, + schedule_id: Optional[EntityID] = None, schedule_periods: Optional[int] = None, comment: Optional[str] = None, - alert_ids: Optional[List[str]] = None, - observers: Optional[List[str]] = None, - preferences: Optional[dict] = None, - ) -> Any: + alert_ids: Optional[Sequence[EntityID]] = None, + observers: Optional[Sequence[str]] = None, + preferences: Optional[Mapping[str, SupportsStr]] = None, + ) -> Request: """Modifies an existing task. - Arguments: + Args: task_id: UUID of task to modify. name: The name of the task. config_id: UUID of scan config to use by the task @@ -315,17 +282,14 @@ def modify_task( observers: List of names or ids of users which should be allowed to observe this task preferences: Name/Value pairs of scanner preferences. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.modify_task.__name__, argument="task_id argument" + function=cls.modify_task.__name__, argument="task_id" ) cmd = XmlCommand("modify_task") - cmd.set_attribute("task_id", task_id) + cmd.set_attribute("task_id", str(task_id)) if name: cmd.add_element("name", name) @@ -334,28 +298,24 @@ def modify_task( cmd.add_element("comment", comment) if config_id: - cmd.add_element("config", attrs={"id": config_id}) + cmd.add_element("config", attrs={"id": str(config_id)}) if target_id: - cmd.add_element("target", attrs={"id": target_id}) + cmd.add_element("target", attrs={"id": str(target_id)}) if alterable is not None: cmd.add_element("alterable", to_bool(alterable)) if hosts_ordering: if not isinstance(hosts_ordering, HostsOrdering): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="hosts_ordering", - arg_type=HostsOrdering.__name__, - ) + hosts_ordering = HostsOrdering(hosts_ordering) cmd.add_element("hosts_ordering", hosts_ordering.value) if scanner_id: - cmd.add_element("scanner", attrs={"id": scanner_id}) + cmd.add_element("scanner", attrs={"id": str(scanner_id)}) if schedule_id: - cmd.add_element("schedule", attrs={"id": schedule_id}) + cmd.add_element("schedule", attrs={"id": str(schedule_id)}) if schedule_periods is not None: if ( @@ -369,13 +329,6 @@ def modify_task( cmd.add_element("schedule_periods", str(schedule_periods)) if alert_ids is not None: - if not is_list_like(alert_ids): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="alert_ids", - arg_type="list", - ) - if len(alert_ids) == 0: cmd.add_element("alert", attrs={"id": "0"}) else: @@ -383,107 +336,84 @@ def modify_task( cmd.add_element("alert", attrs={"id": str(alert)}) if observers is not None: - if not is_list_like(observers): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="observers", - arg_type="list", - ) - cmd.add_element("observers", to_comma_list(observers)) if preferences is not None: - if not isinstance(preferences, Mapping): - raise InvalidArgumentType( - function=self.modify_task.__name__, - argument="preferences", - arg_type=Mapping.__name__, - ) - - _xmlprefs = cmd.add_element("preferences") + xml_prefs = cmd.add_element("preferences") for pref_name, pref_value in preferences.items(): - _xmlpref = _xmlprefs.add_element("preference") - _xmlpref.add_element("scanner_name", pref_name) - _xmlpref.add_element("value", str(pref_value)) + xml_pref = xml_prefs.add_element("preference") + xml_pref.add_element("scanner_name", pref_name) + xml_pref.add_element("value", str(pref_value)) - return self._send_xml_command(cmd) + return cmd - def move_task(self, task_id: str, *, slave_id: Optional[str] = None) -> Any: + @classmethod + def move_task( + cls, task_id: EntityID, *, slave_id: Optional[EntityID] = None + ) -> Request: """Move an existing task to another GMP slave scanner or the master - Arguments: + Args: task_id: UUID of the task to be moved - slave_id: UUID of slave to reassign the task to, empty for master. - - Returns: - The response. See :py:meth:`send_command` for details. + slave_id: UUID of the sensor to reassign the task to, empty for master. """ if not task_id: raise RequiredArgument( - function=self.move_task.__name__, argument="task_id" + function=cls.move_task.__name__, argument="task_id" ) cmd = XmlCommand("move_task") - cmd.set_attribute("task_id", task_id) + cmd.set_attribute("task_id", str(task_id)) if slave_id is not None: - cmd.set_attribute("slave_id", slave_id) + cmd.set_attribute("slave_id", str(slave_id)) - return self._send_xml_command(cmd) + return cmd - def start_task(self, task_id: str) -> Any: + @classmethod + def start_task(cls, task_id: EntityID) -> Request: """Start an existing task - Arguments: + Args: task_id: UUID of the task to be started - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.start_task.__name__, argument="task_id" + function=cls.start_task.__name__, argument="task_id" ) cmd = XmlCommand("start_task") - cmd.set_attribute("task_id", task_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(task_id)) + return cmd - def resume_task(self, task_id: str) -> Any: + @classmethod + def resume_task(cls, task_id: EntityID) -> Request: """Resume an existing stopped task - Arguments: + Args: task_id: UUID of the task to be resumed - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.resume_task.__name__, argument="task_id" + function=cls.resume_task.__name__, argument="task_id" ) cmd = XmlCommand("resume_task") - cmd.set_attribute("task_id", task_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(task_id)) + return cmd - def stop_task(self, task_id: str) -> Any: + @classmethod + def stop_task(cls, task_id: EntityID) -> Request: """Stop an existing running task - Arguments: + Args: task_id: UUID of the task to be stopped - - Returns: - The response. See :py:meth:`send_command` for details. """ if not task_id: raise RequiredArgument( - function=self.stop_task.__name__, argument="task_id" + function=cls.stop_task.__name__, argument="task_id" ) cmd = XmlCommand("stop_task") - cmd.set_attribute("task_id", task_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("task_id", str(task_id)) + return cmd diff --git a/gvm/protocols/gmpv208/entities/tickets.py b/gvm/protocols/gmp/requests/v224/_tickets.py similarity index 53% rename from gvm/protocols/gmpv208/entities/tickets.py rename to gvm/protocols/gmp/requests/v224/_tickets.py index cfdcddb78..8c1dbd82c 100644 --- a/gvm/protocols/gmpv208/entities/tickets.py +++ b/gvm/protocols/gmp/requests/v224/_tickets.py @@ -1,15 +1,17 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + class TicketStatus(Enum): """Enum for ticket status""" @@ -19,194 +21,181 @@ class TicketStatus(Enum): CLOSED = "Closed" -class TicketsMixin: - def clone_ticket(self, ticket_id: str) -> Any: +class Tickets: + + @classmethod + def clone_ticket(cls, ticket_id: EntityID) -> Request: """Clone an existing ticket - Arguments: + Args: ticket_id: UUID of an existing ticket to clone from - - Returns: - The response. See :py:meth:`send_command` for details. """ if not ticket_id: raise RequiredArgument( - function=self.clone_ticket.__name__, argument="ticket_id" + function=cls.clone_ticket.__name__, argument="ticket_id" ) cmd = XmlCommand("create_ticket") - cmd.add_element("copy", ticket_id) + cmd.add_element("copy", str(ticket_id)) - return self._send_xml_command(cmd) + return cmd + @classmethod def create_ticket( - self, + cls, *, - result_id: str, - assigned_to_user_id: str, + result_id: EntityID, + assigned_to_user_id: EntityID, note: str, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Create a new ticket - Arguments: + Args: result_id: UUID of the result the ticket applies to assigned_to_user_id: UUID of a user the ticket should be assigned to note: A note about opening the ticket comment: Comment for the ticket - - Returns: - The response. See :py:meth:`send_command` for details. """ if not result_id: raise RequiredArgument( - function=self.create_ticket.__name__, argument="result_id" + function=cls.create_ticket.__name__, argument="result_id" ) if not assigned_to_user_id: raise RequiredArgument( - function=self.create_ticket.__name__, + function=cls.create_ticket.__name__, argument="assigned_to_user_id", ) if not note: raise RequiredArgument( - function=self.create_ticket.__name__, argument="note" + function=cls.create_ticket.__name__, argument="note" ) cmd = XmlCommand("create_ticket") - _result = cmd.add_element("result") - _result.set_attribute("id", result_id) + result = cmd.add_element("result") + result.set_attribute("id", str(result_id)) - _assigned = cmd.add_element("assigned_to") - _user = _assigned.add_element("user") - _user.set_attribute("id", assigned_to_user_id) + assigned = cmd.add_element("assigned_to") + user = assigned.add_element("user") + user.set_attribute("id", str(assigned_to_user_id)) cmd.add_element("open_note", note) if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd + @classmethod def delete_ticket( - self, ticket_id: str, *, ultimate: Optional[bool] = False - ): + cls, ticket_id: EntityID, *, ultimate: Optional[bool] = False + ) -> Request: """Deletes an existing ticket - Arguments: + Args: ticket_id: UUID of the ticket to be deleted. ultimate: Whether to remove entirely, or to the trashcan. """ if not ticket_id: raise RequiredArgument( - function=self.delete_ticket.__name__, argument="ticket_id" + function=cls.delete_ticket.__name__, argument="ticket_id" ) cmd = XmlCommand("delete_ticket") - cmd.set_attribute("ticket_id", ticket_id) + cmd.set_attribute("ticket_id", str(ticket_id)) cmd.set_attribute("ultimate", to_bool(ultimate)) - return self._send_xml_command(cmd) + return cmd + @staticmethod def get_tickets( - self, *, trash: Optional[bool] = None, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - ) -> Any: + filter_id: Optional[EntityID] = None, + ) -> Request: """Request a list of tickets - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query trash: True to request the tickets in the trashcan - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_tickets") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if trash is not None: cmd.set_attribute("trash", to_bool(trash)) - return self._send_xml_command(cmd) + return cmd - def get_ticket(self, ticket_id: str) -> Any: + @classmethod + def get_ticket(cls, ticket_id: EntityID) -> Request: """Request a single ticket - Arguments: + Args: ticket_id: UUID of an existing ticket - - Returns: - The response. See :py:meth:`send_command` for details. """ if not ticket_id: raise RequiredArgument( - function=self.get_ticket.__name__, argument="ticket_id" + function=cls.get_ticket.__name__, argument="ticket_id" ) cmd = XmlCommand("get_tickets") - cmd.set_attribute("ticket_id", ticket_id) - return self._send_xml_command(cmd) + cmd.set_attribute("ticket_id", str(ticket_id)) + return cmd + @classmethod def modify_ticket( - self, - ticket_id: str, + cls, + ticket_id: EntityID, *, - status: Optional[TicketStatus] = None, + status: Optional[Union[TicketStatus, str]] = None, note: Optional[str] = None, - assigned_to_user_id: Optional[str] = None, + assigned_to_user_id: Optional[EntityID] = None, comment: Optional[str] = None, - ) -> Any: + ) -> Request: """Modify a single ticket - Arguments: + Args: ticket_id: UUID of an existing ticket status: New status for the ticket note: Note for the status change. Required if status is set. assigned_to_user_id: UUID of the user the ticket should be assigned to comment: Comment for the ticket - - Returns: - The response. See :py:meth:`send_command` for details. """ if not ticket_id: raise RequiredArgument( - function=self.modify_ticket.__name__, argument="ticket_id" + function=cls.modify_ticket.__name__, argument="ticket_id" ) if status and not note: raise RequiredArgument( - function=self.modify_ticket.__name__, argument="note" + function=cls.modify_ticket.__name__, argument="note" ) if note and not status: raise RequiredArgument( - function=self.modify_ticket.__name__, argument="status" + function=cls.modify_ticket.__name__, argument="status" ) cmd = XmlCommand("modify_ticket") - cmd.set_attribute("ticket_id", ticket_id) + cmd.set_attribute("ticket_id", str(ticket_id)) if assigned_to_user_id: - _assigned = cmd.add_element("assigned_to") - _user = _assigned.add_element("user") - _user.set_attribute("id", assigned_to_user_id) + assigned = cmd.add_element("assigned_to") + user = assigned.add_element("user") + user.set_attribute("id", str(assigned_to_user_id)) if status: if not isinstance(status, TicketStatus): - raise InvalidArgumentType( - function=self.modify_ticket.__name__, - argument="status", - arg_type=TicketStatus.__name__, - ) + status = TicketStatus(status) cmd.add_element("status", status.value) cmd.add_element(f"{status.name.lower()}_note", note) @@ -214,4 +203,4 @@ def modify_ticket( if comment: cmd.add_element("comment", comment) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/entities/tls_certificates.py b/gvm/protocols/gmp/requests/v224/_tls_certificates.py similarity index 67% rename from gvm/protocols/gmpv208/entities/tls_certificates.py rename to gvm/protocols/gmp/requests/v224/_tls_certificates.py index 010469f7f..18f74c93b 100644 --- a/gvm/protocols/gmpv208/entities/tls_certificates.py +++ b/gvm/protocols/gmp/requests/v224/_tls_certificates.py @@ -1,122 +1,116 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool +from gvm.protocols.core import Request +from gvm.utils import to_bool from gvm.xml import XmlCommand +from .._entity_id import EntityID + -class TLSCertificateMixin: - def clone_tls_certificate(self, tls_certificate_id: str) -> Any: +class TLSCertificates: + @classmethod + def clone_tls_certificate(cls, tls_certificate_id: EntityID) -> Request: """Modifies an existing TLS certificate. - Arguments: + Args: tls_certificate_id: The UUID of an existing TLS certificate - - Returns: - The response. See :py:meth:`send_command` for details. """ if not tls_certificate_id: raise RequiredArgument( - function=self.clone_tls_certificate.__name__, + function=cls.clone_tls_certificate.__name__, argument="tls_certificate_id", ) cmd = XmlCommand("create_tls_certificate") - cmd.add_element("copy", tls_certificate_id) + cmd.add_element("copy", str(tls_certificate_id)) - return self._send_xml_command(cmd) + return cmd + @classmethod def create_tls_certificate( - self, + cls, name: str, certificate: str, *, comment: Optional[str] = None, trust: Optional[bool] = None, - ) -> Any: + ) -> Request: """Create a new TLS certificate - Arguments: + Args: name: Name of the TLS certificate, defaulting to the MD5 fingerprint. certificate: The Base64 encoded certificate data (x.509 DER or PEM). comment: Comment for the TLS certificate. trust: Whether the certificate is trusted. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not name: raise RequiredArgument( - function=self.create_tls_certificate.__name__, argument="name" + function=cls.create_tls_certificate.__name__, argument="name" ) if not certificate: raise RequiredArgument( - function=self.create_tls_certificate.__name__, + function=cls.create_tls_certificate.__name__, argument="certificate", ) cmd = XmlCommand("create_tls_certificate") - if comment: - cmd.add_element("comment", comment) - cmd.add_element("name", name) cmd.add_element("certificate", certificate) - if trust: + if comment: + cmd.add_element("comment", comment) + + if trust is not None: cmd.add_element("trust", to_bool(trust)) - return self._send_xml_command(cmd) + return cmd - def delete_tls_certificate(self, tls_certificate_id: str) -> Any: + @classmethod + def delete_tls_certificate(cls, tls_certificate_id: EntityID) -> Request: """Deletes an existing tls certificate - Arguments: + Args: tls_certificate_id: UUID of the tls certificate to be deleted. """ if not tls_certificate_id: raise RequiredArgument( - function=self.delete_tls_certificate.__name__, + function=cls.delete_tls_certificate.__name__, argument="tls_certificate_id", ) cmd = XmlCommand("delete_tls_certificate") - cmd.set_attribute("tls_certificate_id", tls_certificate_id) - - return self._send_xml_command(cmd) + cmd.set_attribute("tls_certificate_id", str(tls_certificate_id)) + return cmd + @staticmethod def get_tls_certificates( - self, *, filter_string: Optional[str] = None, - filter_id: Optional[str] = None, + filter_id: Optional[EntityID] = None, include_certificate_data: Optional[bool] = None, details: Optional[bool] = None, - ) -> Any: + ) -> Request: """Request a list of TLS certificates - Arguments: + Args: filter_string: Filter term to use for the query filter_id: UUID of an existing filter to use for the query include_certificate_data: Whether to include the certificate data in the response details: Whether to include additional details of the tls certificates - - Returns: - The response. See :py:meth:`send_command` for details. """ - cmd = XmlCommand("get_tls_certificates") - add_filter(cmd, filter_string, filter_id) + cmd.add_filter(filter_string, filter_id) if details is not None: cmd.set_attribute("details", to_bool(details)) @@ -126,26 +120,24 @@ def get_tls_certificates( "include_certificate_data", to_bool(include_certificate_data) ) - return self._send_xml_command(cmd) + return cmd - def get_tls_certificate(self, tls_certificate_id: str) -> Any: + @classmethod + def get_tls_certificate(cls, tls_certificate_id: EntityID) -> Request: """Request a single TLS certificate - Arguments: + Args: tls_certificate_id: UUID of an existing TLS certificate - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_tls_certificates") if not tls_certificate_id: raise RequiredArgument( - function=self.get_tls_certificate.__name__, + function=cls.get_tls_certificate.__name__, argument="tls_certificate_id", ) - cmd.set_attribute("tls_certificate_id", tls_certificate_id) + cmd.set_attribute("tls_certificate_id", str(tls_certificate_id)) # for single tls certificate always request cert data cmd.set_attribute("include_certificate_data", "1") @@ -153,30 +145,28 @@ def get_tls_certificate(self, tls_certificate_id: str) -> Any: # for single entity always request all details cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) + return cmd + @classmethod def modify_tls_certificate( - self, - tls_certificate_id: str, + cls, + tls_certificate_id: EntityID, *, name: Optional[str] = None, comment: Optional[str] = None, trust: Optional[bool] = None, - ) -> Any: + ) -> Request: """Modifies an existing TLS certificate. - Arguments: + Args: tls_certificate_id: UUID of the TLS certificate to be modified. name: Name of the TLS certificate, defaulting to the MD5 fingerprint comment: Comment for the TLS certificate. trust: Whether the certificate is trusted. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not tls_certificate_id: raise RequiredArgument( - function=self.modify_tls_certificate.__name__, + function=cls.modify_tls_certificate.__name__, argument="tls_certificate_id", ) @@ -189,7 +179,7 @@ def modify_tls_certificate( if name: cmd.add_element("name", name) - if trust: + if trust is not None: cmd.add_element("trust", to_bool(trust)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_trashcan.py b/gvm/protocols/gmp/requests/v224/_trashcan.py new file mode 100644 index 000000000..c35518a07 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_trashcan.py @@ -0,0 +1,39 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class TrashCan: + @staticmethod + def empty_trashcan() -> Request: + """Empty the trashcan + + Remove all entities from the trashcan. **Attention:** this command can + not be reverted + """ + return XmlCommand("empty_trashcan") + + @classmethod + def restore_from_trashcan(cls, entity_id: EntityID) -> Request: + """Restore an entity from the trashcan + + Args: + entity_id: ID of the entity to be restored from the trashcan + """ + + if not entity_id: + raise RequiredArgument( + function=cls.restore_from_trashcan.__name__, + argument="entity_id", + ) + + cmd = XmlCommand("restore") + cmd.set_attribute("id", str(entity_id)) + + return cmd diff --git a/gvm/protocols/gmpv208/system/user_settings.py b/gvm/protocols/gmp/requests/v224/_user_settings.py similarity index 59% rename from gvm/protocols/gmpv208/system/user_settings.py rename to gvm/protocols/gmp/requests/v224/_user_settings.py index ac9fc8629..45e2b145f 100644 --- a/gvm/protocols/gmpv208/system/user_settings.py +++ b/gvm/protocols/gmp/requests/v224/_user_settings.py @@ -3,85 +3,83 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from typing import Any, Optional +from typing import Optional from gvm.errors import RequiredArgument +from gvm.protocols.core import Request from gvm.utils import to_base64 from gvm.xml import XmlCommand +from .._entity_id import EntityID -class UserSettingsMixin: - def get_user_settings(self, *, filter_string: Optional[str] = None) -> Any: + +class UserSettings: + @staticmethod + def get_user_settings(*, filter_string: Optional[str] = None) -> Request: """Request a list of user settings - Arguments: + Args: filter_string: Filter term to use for the query - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_settings") if filter_string: cmd.set_attribute("filter", filter_string) - return self._send_xml_command(cmd) + return cmd - def get_user_setting(self, setting_id: str) -> Any: + @classmethod + def get_user_setting(cls, setting_id: EntityID) -> Request: """Request a single user setting - Arguments: + Args: setting_id: UUID of an existing setting - - Returns: - The response. See :py:meth:`send_command` for details. """ cmd = XmlCommand("get_settings") if not setting_id: raise RequiredArgument( - function=self.get_user_setting.__name__, argument="setting_id" + function=cls.get_user_setting.__name__, argument="setting_id" ) - cmd.set_attribute("setting_id", setting_id) - return self._send_xml_command(cmd) + cmd.set_attribute("setting_id", str(setting_id)) + return cmd + @classmethod def modify_user_setting( - self, - setting_id: Optional[str] = None, + cls, + *, + setting_id: Optional[EntityID] = None, name: Optional[str] = None, value: Optional[str] = None, - ) -> Any: + ) -> Request: """Modifies an existing user setting. - Arguments: + Args: setting_id: UUID of the setting to be changed. name: The name of the setting. Either setting_id or name must be passed. value: The value of the setting. - - Returns: - The response. See :py:meth:`send_command` for details. """ if not setting_id and not name: raise RequiredArgument( - function=self.modify_user_setting.__name__, + function=cls.modify_user_setting.__name__, argument="setting_id or name argument", ) if value is None: raise RequiredArgument( - function=self.modify_user_setting.__name__, + function=cls.modify_user_setting.__name__, argument="value argument", ) cmd = XmlCommand("modify_setting") if setting_id: - cmd.set_attribute("setting_id", setting_id) + cmd.set_attribute("setting_id", str(setting_id)) else: cmd.add_element("name", name) cmd.add_element("value", to_base64(value)) - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_users.py b/gvm/protocols/gmp/requests/v224/_users.py new file mode 100644 index 000000000..d84097d7f --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_users.py @@ -0,0 +1,235 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional, Union + +from gvm._enum import Enum +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool, to_comma_list +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class UserAuthType(Enum): + """Enum for Sources allowed for authentication for the user""" + + FILE = "file" + LDAP_CONNECT = "ldap_connect" + RADIUS_CONNECT = "radius_connect" + + +class Users: + + @classmethod + def create_user( + cls, + name: str, + *, + password: Optional[str] = None, + hosts: Optional[list[str]] = None, + hosts_allow: Optional[bool] = False, + role_ids: Optional[list[EntityID]] = None, + ) -> Request: + """Create a new user + + Args: + name: Name of the user + password: Password of the user + hosts: A list of host addresses (IPs, DNS names) + hosts_allow: If True allow only access to passed hosts otherwise + deny access. Default is False for deny hosts. + role_ids: A list of role UUIDs for the user + """ + if not name: + raise RequiredArgument( + function=cls.create_user.__name__, argument="name" + ) + + cmd = XmlCommand("create_user") + cmd.add_element("name", name) + + if password: + cmd.add_element("password", password) + + if hosts: + cmd.add_element( + "hosts", + to_comma_list(hosts), + attrs={"allow": to_bool(hosts_allow)}, + ) + + if role_ids: + for role in role_ids: + cmd.add_element("role", attrs={"id": str(role)}) + + return cmd + + @classmethod + def modify_user( + cls, + user_id: EntityID, + *, + name: Optional[str] = None, + comment: Optional[str] = None, + password: Optional[str] = None, + auth_source: Optional[Union[UserAuthType, str]] = None, + role_ids: Optional[list[EntityID]] = None, + hosts: Optional[list[str]] = None, + hosts_allow: Optional[bool] = False, + group_ids: Optional[list[EntityID]] = None, + ) -> Request: + """Modify an existing user. + + Most of the fields need to be supplied + for changing a single field even if no change is wanted for those. + Else empty values are inserted for the missing fields instead. + + Args: + user_id: UUID of the user to be modified. + name: The new name for the user. + comment: Comment on the user. + password: The password for the user. + auth_source: Source allowed for authentication for this user. + roles_id: List of roles UUIDs for the user. + hosts: User access rules: List of hosts. + hosts_allow: Defines how the hosts list is to be interpreted. + If False (default) the list is treated as a deny list. + All hosts are allowed by default except those provided by + the hosts parameter. If True the list is treated as a + allow list. All hosts are denied by default except those + provided by the hosts parameter. + group_ids: List of group UUIDs for the user. + """ + if not user_id: + raise RequiredArgument( + function=cls.modify_user.__name__, argument="user_id" + ) + + cmd = XmlCommand("modify_user") + + cmd.set_attribute("user_id", str(user_id)) + + if name: + cmd.add_element("new_name", name) + + if role_ids: + for role in role_ids: + cmd.add_element("role", attrs={"id": role}) + + if hosts: + cmd.add_element( + "hosts", + to_comma_list(hosts), + attrs={"allow": to_bool(hosts_allow)}, + ) + + if comment: + cmd.add_element("comment", comment) + + if password: + cmd.add_element("password", password) + + if auth_source: + xml_auth_src = cmd.add_element("sources") + if not isinstance(auth_source, UserAuthType): + auth_source = UserAuthType(auth_source) + xml_auth_src.add_element("source", auth_source.value) + + if group_ids: + xml_groups = cmd.add_element("groups") + for group_id in group_ids: + xml_groups.add_element("group", attrs={"id": group_id}) + + return cmd + + @classmethod + def clone_user(cls, user_id: EntityID) -> Request: + """Clone an existing user. + + Args: + user_id: UUID of the user to be cloned. + """ + if not user_id: + raise RequiredArgument( + function=cls.clone_user.__name__, argument="user_id" + ) + + cmd = XmlCommand("create_user") + cmd.add_element("copy", str(user_id)) + return cmd + + @classmethod + def delete_user( + cls, + user_id: Optional[EntityID] = None, + *, + name: Optional[str] = None, + inheritor_id: Optional[EntityID] = None, + inheritor_name: Optional[str] = None, + ) -> Request: + """Delete an existing user + + Either user_id or name must be passed. + + Args: + user_id: UUID of the task to be deleted. + name: The name of the user to be deleted. + inheritor_id: The UUID of the inheriting user or "self". Overrides + inheritor_name. + inheritor_name: The name of the inheriting user. + + """ + if not user_id and not name: + raise RequiredArgument( + function=cls.delete_user.__name__, argument="user_id or name" + ) + + cmd = XmlCommand("delete_user") + + if user_id: + cmd.set_attribute("user_id", str(user_id)) + + if name: + cmd.set_attribute("name", name) + + if inheritor_id: + cmd.set_attribute("inheritor_id", str(inheritor_id)) + if inheritor_name: + cmd.set_attribute("inheritor_name", inheritor_name) + + return cmd + + @staticmethod + def get_users( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + ) -> Request: + """Request a list of users + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + """ + cmd = XmlCommand("get_users") + cmd.add_filter(filter_string, filter_id) + return cmd + + @classmethod + def get_user(cls, user_id: EntityID) -> Request: + """Request a single user + + Args: + user_id: UUID of the user to be requested. + """ + if not user_id: + raise RequiredArgument( + function=cls.get_user.__name__, argument="user_id" + ) + + cmd = XmlCommand("get_users") + cmd.set_attribute("user_id", str(user_id)) + return cmd diff --git a/gvm/protocols/gmp/requests/v224/_vulnerabilities.py b/gvm/protocols/gmp/requests/v224/_vulnerabilities.py new file mode 100644 index 000000000..b09b9abb3 --- /dev/null +++ b/gvm/protocols/gmp/requests/v224/_vulnerabilities.py @@ -0,0 +1,46 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from typing import Optional + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class Vulnerabilities: + @staticmethod + def get_vulnerabilities( + *, + filter_string: Optional[str] = None, + filter_id: Optional[EntityID] = None, + ) -> Request: + """Request a list of vulnerabilities + + Args: + filter_string: Filter term to use for the query + filter_id: UUID of an existing filter to use for the query + """ + cmd = XmlCommand("get_vulns") + cmd.add_filter(filter_string, filter_id) + return cmd + + @classmethod + def get_vulnerability(cls, vulnerability_id: EntityID) -> Request: + """Request a single vulnerability + + Args: + vulnerability_id: ID of an existing vulnerability + """ + if not vulnerability_id: + raise RequiredArgument( + function=cls.get_vulnerability.__name__, + argument="vulnerability_id", + ) + + cmd = XmlCommand("get_vulns") + cmd.set_attribute("vuln_id", str(vulnerability_id)) + return cmd diff --git a/gvm/protocols/gmp/requests/v225/__init__.py b/gvm/protocols/gmp/requests/v225/__init__.py new file mode 100644 index 000000000..028993ed8 --- /dev/null +++ b/gvm/protocols/gmp/requests/v225/__init__.py @@ -0,0 +1,144 @@ +# SPDX-FileCopyrightText: 2018-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later +# +""" +GMP Request implementations for GMP version 22.5. +""" + +from .._entity_id import EntityID +from .._version import Version +from ..v224 import ( + Aggregates, + AggregateStatistic, + AlertCondition, + AlertEvent, + AlertMethod, + Alerts, + AliveTest, + Audits, + Authentication, + CertBundAdvisories, + Cpes, + CredentialFormat, + Credentials, + CredentialType, + Cves, + DfnCertAdvisories, + EntityType, + Feed, + FeedType, + Filters, + FilterType, + Groups, + Help, + HelpFormat, + Hosts, + HostsOrdering, + InfoType, + Notes, + Nvts, + OperatingSystems, + Overrides, + Permissions, + PermissionSubjectType, + Policies, + PortLists, + PortRangeType, + ReportFormats, + ReportFormatType, + Reports, + Results, + Roles, + ScanConfigs, + Scanners, + ScannerType, + Schedules, + SecInfo, + Severity, + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, + SortOrder, + SystemReports, + Tags, + Targets, + Tasks, + Tickets, + TicketStatus, + TLSCertificates, + TrashCan, + UserAuthType, + Users, + UserSettings, + Vulnerabilities, +) +from ._resource_names import ResourceNames, ResourceType + +__all__ = ( + "Aggregates", + "AggregateStatistic", + "Alerts", + "AlertCondition", + "AlertEvent", + "AlertMethod", + "AliveTest", + "Audits", + "Authentication", + "CertBundAdvisories", + "Cpes", + "Credentials", + "CredentialFormat", + "CredentialType", + "Cves", + "DfnCertAdvisories", + "EntityID", + "EntityType", + "Feed", + "FeedType", + "Filters", + "FilterType", + "Groups", + "Help", + "HelpFormat", + "Hosts", + "HostsOrdering", + "InfoType", + "Notes", + "Nvts", + "OperatingSystems", + "Overrides", + "Permissions", + "PermissionSubjectType", + "Policies", + "PortLists", + "PortRangeType", + "ReportFormatType", + "ReportFormats", + "Reports", + "ResourceNames", + "ResourceType", + "Results", + "Roles", + "ScanConfigs", + "Scanners", + "ScannerType", + "Schedules", + "SecInfo", + "Severity", + "SortOrder", + "SnmpAuthAlgorithm", + "SnmpPrivacyAlgorithm", + "SystemReports", + "Tags", + "Targets", + "Tasks", + "Tickets", + "TicketStatus", + "TLSCertificates", + "TrashCan", + "UserAuthType", + "UserSettings", + "Users", + "Version", + "Vulnerabilities", +) diff --git a/gvm/protocols/gmpv225/entities/resourcenames.py b/gvm/protocols/gmp/requests/v225/_resource_names.py similarity index 63% rename from gvm/protocols/gmpv225/entities/resourcenames.py rename to gvm/protocols/gmp/requests/v225/_resource_names.py index 443f6cfad..2521a0b81 100644 --- a/gvm/protocols/gmpv225/entities/resourcenames.py +++ b/gvm/protocols/gmp/requests/v225/_resource_names.py @@ -1,15 +1,16 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG +# SPDX-FileCopyrightText: 2024 Greenbone AG # # SPDX-License-Identifier: GPL-3.0-or-later -# -from typing import Any, Optional +from typing import Optional, Union from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request from gvm.xml import XmlCommand +from .._entity_id import EntityID + class ResourceType(Enum): """Enum for resource types""" @@ -42,15 +43,17 @@ class ResourceType(Enum): USER = "USER" -class ResourceNamesMixin: - def get_resource_names_list( - self, - resource_type: ResourceType, +class ResourceNames: + @classmethod + def get_resource_names( + cls, + resource_type: Union[ResourceType, str], + *, filter_string: Optional[str] = None, - ) -> Any: + ) -> Request: """Request a list of resource names and IDs - Arguments: + Args: resource_type: Type must be either ALERT, CERT_BUND_ADV, CONFIG, CPE, CREDENTIAL, CVE, DFN_CERT_ADV, FILTER, GROUP, HOST, NOTE, NVT, OS, OVERRIDE, PERMISSION, @@ -58,37 +61,31 @@ def get_resource_names_list( SCANNER, SCHEDULE, TARGET, TASK, TLS_CERTIFICATE or USER filter_string: Filter term to use for the query - - Returns: - The response. See :py:meth:`send_command` for details. """ + cmd = XmlCommand("get_resource_names") + if not resource_type: raise RequiredArgument( - function=self.get_resource_names_list.__name__, + function=cls.get_resource_names.__name__, argument="resource_type", ) if not isinstance(resource_type, ResourceType): - raise InvalidArgumentType( - function=self.get_resource_names_list.__name__, - argument="resource_type", - arg_type=ResourceType.__name__, - ) - - cmd = XmlCommand("get_resource_names") + resource_type = ResourceType(resource_type) cmd.set_attribute("type", resource_type.value) + cmd.add_filter(filter_string, None) + return cmd - add_filter(cmd, filter_string, None) - - return self._send_xml_command(cmd) - + @classmethod def get_resource_name( - self, resource_id: str, resource_type: ResourceType - ) -> Any: + cls, + resource_id: EntityID, + resource_type: Union[ResourceType, str], + ) -> Request: """Request a single resource name - Arguments: + Args: resource_id: ID of an existing resource resource_type: Type must be either ALERT, CERT_BUND_ADV, CONFIG, CPE, CREDENTIAL, CVE, DFN_CERT_ADV, FILTER, @@ -96,31 +93,22 @@ def get_resource_name( PORT_LIST, REPORT_FORMAT, REPORT, RESULT, ROLE, SCANNER, SCHEDULE, TARGET, TASK, TLS_CERTIFICATE or USER - - Returns: - The response. See :py:meth:`send_command` for details. """ if not resource_type: raise RequiredArgument( - function=self.get_resource_name.__name__, + function=cls.get_resource_name.__name__, argument="resource_type", ) if not isinstance(resource_type, ResourceType): - raise InvalidArgumentType( - function=self.get_resource_name.__name__, - argument="resource_type", - arg_type=ResourceType.__name__, - ) + resource_type = ResourceType(resource_type) if not resource_id: raise RequiredArgument( - function=self.get_resource_name.__name__, argument="resource_id" + function=cls.get_resource_name.__name__, argument="resource_id" ) cmd = XmlCommand("get_resource_names") - cmd.set_attribute("resource_id", resource_id) - + cmd.set_attribute("resource_id", str(resource_id)) cmd.set_attribute("type", resource_type.value) - - return self._send_xml_command(cmd) + return cmd diff --git a/gvm/protocols/gmpv208/__init__.py b/gvm/protocols/gmpv208/__init__.py deleted file mode 100644 index 5645093c9..000000000 --- a/gvm/protocols/gmpv208/__init__.py +++ /dev/null @@ -1,183 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=too-many-lines,redefined-builtin -""" -Module for communication with gvmd in -`Greenbone Management Protocol version 20.08`_ - -.. _Greenbone Management Protocol version 20.08: - https://docs.greenbone.net/API/GMP/gmp-20.08.html -""" - -import logging -from typing import Any, Callable, Optional - -from gvm.connections import GvmConnection -from gvm.protocols.base import GvmProtocol -from gvm.protocols.gmpv208.entities.alerts import ( - AlertCondition, - AlertEvent, - AlertMethod, - AlertsMixin, -) -from gvm.protocols.gmpv208.entities.audits import AuditsMixin -from gvm.protocols.gmpv208.entities.credentials import ( - CredentialFormat, - CredentialsMixin, - CredentialType, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, -) -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.protocols.gmpv208.entities.filter import FiltersMixin, FilterType -from gvm.protocols.gmpv208.entities.groups import GroupsMixin -from gvm.protocols.gmpv208.entities.hosts import HostsMixin, HostsOrdering -from gvm.protocols.gmpv208.entities.notes import NotesMixin -from gvm.protocols.gmpv208.entities.operating_systems import ( - OperatingSystemsMixin, -) -from gvm.protocols.gmpv208.entities.overrides import OverridesMixin -from gvm.protocols.gmpv208.entities.permissions import ( - PermissionsMixin, - PermissionSubjectType, -) -from gvm.protocols.gmpv208.entities.policies import PoliciesMixin -from gvm.protocols.gmpv208.entities.port_lists import ( - PortListMixin, - PortRangeType, -) -from gvm.protocols.gmpv208.entities.report_formats import ( - ReportFormatsMixin, - ReportFormatType, -) -from gvm.protocols.gmpv208.entities.reports import ReportsMixin -from gvm.protocols.gmpv208.entities.results import ResultsMixin -from gvm.protocols.gmpv208.entities.roles import RolesMixin -from gvm.protocols.gmpv208.entities.scan_configs import ScanConfigsMixin -from gvm.protocols.gmpv208.entities.scanners import ScannersMixin, ScannerType -from gvm.protocols.gmpv208.entities.schedules import SchedulesMixin -from gvm.protocols.gmpv208.entities.secinfo import InfoType, SecInfoMixin -from gvm.protocols.gmpv208.entities.severity import SeverityLevel -from gvm.protocols.gmpv208.entities.tags import TagsMixin -from gvm.protocols.gmpv208.entities.targets import AliveTest, TargetsMixin -from gvm.protocols.gmpv208.entities.tasks import TasksMixin -from gvm.protocols.gmpv208.entities.tickets import TicketsMixin, TicketStatus -from gvm.protocols.gmpv208.entities.tls_certificates import TLSCertificateMixin -from gvm.protocols.gmpv208.entities.users import UserAuthType, UsersMixin -from gvm.protocols.gmpv208.entities.vulnerabilities import VulnerabilitiesMixin -from gvm.protocols.gmpv208.system.aggregates import ( - AggregatesMixin, - AggregateStatistic, - SortOrder, -) -from gvm.protocols.gmpv208.system.authentication import AuthenticationMixin -from gvm.protocols.gmpv208.system.feed import FeedMixin, FeedType -from gvm.protocols.gmpv208.system.help import HelpFormat, HelpMixin -from gvm.protocols.gmpv208.system.system_reports import SystemReportsMixin -from gvm.protocols.gmpv208.system.trashcan import TrashcanMixin -from gvm.protocols.gmpv208.system.user_settings import UserSettingsMixin -from gvm.protocols.gmpv208.system.version import VersionMixin -from gvm.utils import to_dotted_types_dict - -logger = logging.getLogger(__name__) - -_TYPE_FIELDS = [ - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - HostsOrdering, - InfoType, - HelpFormat, - PortRangeType, - PermissionSubjectType, - ReportFormatType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, -] - - -class Gmp( - GvmProtocol, - AggregatesMixin, - AlertsMixin, - AuditsMixin, - AuthenticationMixin, - CredentialsMixin, - FeedMixin, - FiltersMixin, - GroupsMixin, - HelpMixin, - HostsMixin, - NotesMixin, - OperatingSystemsMixin, - OverridesMixin, - PermissionsMixin, - PoliciesMixin, - PortListMixin, - ReportFormatsMixin, - ReportsMixin, - ResultsMixin, - RolesMixin, - TagsMixin, - TargetsMixin, - TasksMixin, - TicketsMixin, - TLSCertificateMixin, - TrashcanMixin, - ScanConfigsMixin, - ScannersMixin, - SchedulesMixin, - SecInfoMixin, - SystemReportsMixin, - UserSettingsMixin, - UsersMixin, - VersionMixin, - VulnerabilitiesMixin, -): - """Python interface for Greenbone Management Protocol - - This class implements the `Greenbone Management Protocol version 20.08`_ - - Arguments: - connection: Connection to use to talk with the gvmd daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - - .. _Greenbone Management Protocol version 20.08: - https://docs.greenbone.net/API/GMP/gmp-20.08.html - .. _callable: - https://docs.python.org/3/library/functions.html#callable - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - super().__init__(connection, transform=transform) - - self.types = to_dotted_types_dict(_TYPE_FIELDS) - - # Is authenticated on gvmd - self._authenticated = False diff --git a/gvm/protocols/gmpv208/entities/__init__.py b/gvm/protocols/gmpv208/entities/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv208/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv208/entities/notes.py b/gvm/protocols/gmpv208/entities/notes.py deleted file mode 100644 index fb1f98560..000000000 --- a/gvm/protocols/gmpv208/entities/notes.py +++ /dev/null @@ -1,264 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.severity import Severity, SeverityLevel -from gvm.utils import add_filter, check_port, to_bool, to_comma_list -from gvm.xml import XmlCommand - - -class NotesMixin: - def create_note( - self, - text: str, - nvt_oid: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[str] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Optional[SeverityLevel] = None, - ) -> Any: - """Create a new note - - Arguments: - text: Text of the new note - nvt_id: OID of the nvt to which note applies - days_active: Days note will be active. -1 on - always, 0 off - hosts: A list of hosts addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: UUID of a result to which note applies - severity: Severity to which note applies - task_id: UUID of task to which note applies - threat: Severity level to which note applies. Will be converted to - severity. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not text: - raise RequiredArgument( - function=self.create_note.__name__, argument="text" - ) - - if not nvt_oid: - raise RequiredArgument( - function=self.create_note.__name__, argument="nvt_oid" - ) - - cmd = XmlCommand("create_note") - cmd.add_element("text", text) - cmd.add_element("nvt", attrs={"oid": nvt_oid}) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.create_note.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - if not isinstance(threat, SeverityLevel): - raise InvalidArgumentType( - function="create_note", - argument="threat", - arg_type=SeverityLevel.__name__, - ) - - cmd.add_element("threat", threat.value) - - return self._send_xml_command(cmd) - - def clone_note(self, note_id: str) -> Any: - """Clone an existing note - - Arguments: - note_id: UUID of an existing note to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not note_id: - raise RequiredArgument( - function=self.clone_note.__name__, argument="note_id" - ) - - cmd = XmlCommand("create_note") - cmd.add_element("copy", note_id) - return self._send_xml_command(cmd) - - def delete_note( - self, note_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing note - - Arguments: - note_id: UUID of the note to be deleted. - ultimate: Whether to remove entirely,or to the trashcan. - """ - if not note_id: - raise RequiredArgument( - function=self.delete_note.__name__, argument="note_id" - ) - - cmd = XmlCommand("delete_note") - cmd.set_attribute("note_id", note_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) - - return self._send_xml_command(cmd) - - def get_notes( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - details: Optional[bool] = None, - result: Optional[bool] = None, - ) -> Any: - """Request a list of notes - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - details: Add info about connected results and tasks - result: Return the details of possible connected results. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_notes") - - add_filter(cmd, filter_string, filter_id) - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - if result is not None: - cmd.set_attribute("result", to_bool(result)) - - return self._send_xml_command(cmd) - - def get_note(self, note_id: str) -> Any: - """Request a single note - - Arguments: - note_id: UUID of an existing note - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not note_id: - raise RequiredArgument( - function=self.get_note.__name__, argument="note_id" - ) - - cmd = XmlCommand("get_notes") - cmd.set_attribute("note_id", note_id) - - # for single entity always request all details - cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) - - def modify_note( - self, - note_id: str, - text: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[str] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Optional[SeverityLevel] = None, - ) -> Any: - """Modifies an existing note. - - Arguments: - note_id: UUID of note to modify. - text: The text of the note. - days_active: Days note will be active. -1 on always, 0 off. - hosts: A list of hosts addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: Result to which note applies. - severity: Severity to which note applies. - task_id: Task to which note applies. - threat: Threat level to which note applies. Will be converted to - severity. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not note_id: - raise RequiredArgument( - function=self.modify_note.__name__, argument="note_id" - ) - - if not text: - raise RequiredArgument( - function=self.modify_note.__name__, argument="text" - ) - - cmd = XmlCommand("modify_note") - cmd.set_attribute("note_id", note_id) - cmd.add_element("text", text) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.modify_note.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - if not isinstance(threat, SeverityLevel): - raise InvalidArgumentType( - function=self.modify_note.__name__, - argument="threat", - arg_type=SeverityLevel.__name__, - ) - - cmd.add_element("threat", threat.value) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/entities/scan_configs.py b/gvm/protocols/gmpv208/entities/scan_configs.py deleted file mode 100644 index ecc1fbee5..000000000 --- a/gvm/protocols/gmpv208/entities/scan_configs.py +++ /dev/null @@ -1,626 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional, Tuple - -from lxml.etree import XMLSyntaxError - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, deprecation, is_list_like, to_base64, to_bool -from gvm.xml import XmlCommand - - -class ScanConfigsMixin: - def clone_scan_config(self, config_id: str) -> Any: - """Clone a scan config from an existing one - - Arguments: - config_id: UUID of the existing scan config - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not config_id: - raise RequiredArgument( - function=self.clone_scan_config.__name__, argument="config_id" - ) - - cmd = XmlCommand("create_config") - cmd.add_element("copy", config_id) - return self._send_xml_command(cmd) - - def create_scan_config( - self, config_id: str, name: str, *, comment: Optional[str] = None - ) -> Any: - """Create a new scan config - - Arguments: - config_id: UUID of the existing scan config - name: Name of the new scan config - comment: A comment on the config - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_scan_config.__name__, argument="name" - ) - - if not config_id: - raise RequiredArgument( - function=self.create_scan_config.__name__, argument="config_id" - ) - - cmd = XmlCommand("create_config") - if comment is not None: - cmd.add_element("comment", comment) - cmd.add_element("copy", config_id) - cmd.add_element("name", name) - cmd.add_element("usage_type", "scan") - return self._send_xml_command(cmd) - - def create_scan_config_from_osp_scanner( - self, scanner_id: str, name: str, *, comment: Optional[str] = None - ) -> Any: - """Create a new scan config from an ospd scanner. - - Create config by retrieving the expected preferences from the given - scanner via OSP. - - Arguments: - scanner_id: UUID of an OSP scanner to get config data from - name: Name of the new scan config - comment: A comment on the config - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_scan_config_from_osp_scanner.__name__, - argument="name", - ) - - if not scanner_id: - raise RequiredArgument( - function=self.create_scan_config_from_osp_scanner.__name__, - argument="scanner_id", - ) - - cmd = XmlCommand("create_config") - if comment is not None: - cmd.add_element("comment", comment) - cmd.add_element("scanner", scanner_id) - cmd.add_element("name", name) - cmd.add_element("usage_type", "scan") - return self._send_xml_command(cmd) - - def delete_scan_config( - self, config_id: str, *, ultimate: Optional[bool] = False - ) -> Any: - """Deletes an existing config - - Arguments: - config_id: UUID of the config to be deleted. - ultimate: Whether to remove entirely, or to the trashcan. - """ - if not config_id: - raise RequiredArgument( - function=self.delete_scan_config.__name__, argument="config_id" - ) - - cmd = XmlCommand("delete_config") - cmd.set_attribute("config_id", config_id) - cmd.set_attribute("ultimate", to_bool(ultimate)) - - return self._send_xml_command(cmd) - - def get_scan_configs( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - trash: Optional[bool] = None, - details: Optional[bool] = None, - families: Optional[bool] = None, - preferences: Optional[bool] = None, - tasks: Optional[bool] = None, - ) -> Any: - """Request a list of scan configs - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - trash: Whether to get the trashcan scan configs instead - details: Whether to get config families, preferences, nvt selectors - and tasks. - families: Whether to include the families if no details are - requested - preferences: Whether to include the preferences if no details are - requested - tasks: Whether to get tasks using this config - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_configs") - cmd.set_attribute("usage_type", "scan") - - add_filter(cmd, filter_string, filter_id) - - if trash is not None: - cmd.set_attribute("trash", to_bool(trash)) - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - if families is not None: - cmd.set_attribute("families", to_bool(families)) - - if preferences is not None: - cmd.set_attribute("preferences", to_bool(preferences)) - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - return self._send_xml_command(cmd) - - def get_scan_config( - self, config_id: str, *, tasks: Optional[bool] = None - ) -> Any: - """Request a single scan config - - Arguments: - config_id: UUID of an existing scan config - tasks: Whether to get tasks using this config - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not config_id: - raise RequiredArgument( - function=self.get_scan_config.__name__, argument="config_id" - ) - - cmd = XmlCommand("get_configs") - cmd.set_attribute("config_id", config_id) - - cmd.set_attribute("usage_type", "scan") - - if tasks is not None: - cmd.set_attribute("tasks", to_bool(tasks)) - - # for single entity always request all details - cmd.set_attribute("details", "1") - - return self._send_xml_command(cmd) - - def get_scan_config_preferences( - self, *, nvt_oid: Optional[str] = None, config_id: Optional[str] = None - ) -> Any: - """Request a list of scan_config preferences - - When the command includes a config_id attribute, the preference element - includes the preference name, type and value, and the NVT to which the - preference applies. - If the command includes a config_id and an nvt_oid, the preferences for - the given nvt in the config will be shown. - - Arguments: - nvt_oid: OID of nvt - config_id: UUID of scan config of which to show preference values - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_preferences") - - if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) - - if config_id: - cmd.set_attribute("config_id", config_id) - - return self._send_xml_command(cmd) - - def get_scan_config_preference( - self, - name: str, - *, - nvt_oid: Optional[str] = None, - config_id: Optional[str] = None, - ) -> Any: - """Request a nvt preference - - Arguments: - name: name of a particular preference - nvt_oid: OID of nvt - config_id: UUID of scan config of which to show preference values - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_preferences") - - if not name: - raise RequiredArgument( - function=self.get_scan_config_preference.__name__, - argument="name", - ) - - cmd.set_attribute("preference", name) - - if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) - - if config_id: - cmd.set_attribute("config_id", config_id) - - return self._send_xml_command(cmd) - - def import_scan_config(self, config: str) -> Any: - """Import a scan config from XML - - Arguments: - config: Scan Config XML as string to import. This XML must - contain a :code:`` root element. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not config: - raise RequiredArgument( - function=self.import_scan_config.__name__, argument="config" - ) - - cmd = XmlCommand("create_config") - - try: - cmd.append_xml_str(config) - except XMLSyntaxError as e: - raise InvalidArgument( - function=self.import_scan_config.__name__, argument="config" - ) from e - - return self._send_xml_command(cmd) - - def modify_scan_config_set_nvt_preference( - self, - config_id: str, - name: str, - nvt_oid: str, - *, - value: Optional[str] = None, - ) -> Any: - """Modifies the nvt preferences of an existing scan config. - - Arguments: - config_id: UUID of scan config to modify. - name: Name for nvt preference to change. - nvt_oid: OID of the NVT associated with preference to modify - value: New value for the preference. None to delete the preference - and to use the default instead. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, - argument="config_id", - ) - - if not nvt_oid: - raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, - argument="nvt_oid", - ) - - if not name: - raise RequiredArgument( - function=self.modify_scan_config_set_nvt_preference.__name__, - argument="name", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - - _xmlpref = cmd.add_element("preference") - - _xmlpref.add_element("nvt", attrs={"oid": nvt_oid}) - _xmlpref.add_element("name", name) - - if value: - _xmlpref.add_element("value", to_base64(value)) - - return self._send_xml_command(cmd) - - def modify_scan_config_set_name(self, config_id: str, name: str) -> Any: - """Modifies the name of an existing scan config - - Arguments: - config_id: UUID of scan config to modify. - name: New name for the config. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config_set_name.__name__, - argument="config_id", - ) - - if not name: - raise RequiredArgument( - function=self.modify_scan_config_set_name.__name__, - argument="name", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - - cmd.add_element("name", name) - - return self._send_xml_command(cmd) - - def modify_scan_config_set_comment( - self, config_id: str, *, comment: Optional[str] = None - ) -> Any: - """Modifies the comment of an existing scan config - - Arguments: - config_id: UUID of scan config to modify. - comment: Comment to set on a config. Default is an - empty comment and the previous comment will be - removed. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config_set_comment.__name__, - argument="config_id argument", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - if not comment: - comment = "" - cmd.add_element("comment", comment) - - return self._send_xml_command(cmd) - - def modify_scan_config_set_scanner_preference( - self, config_id: str, name: str, *, value: Optional[str] = None - ) -> Any: - """Modifies the scanner preferences of an existing scan config - - Arguments: - config_id: UUID of scan config to modify. - name: Name of the scanner preference to change - value: New value for the preference. None to delete the preference - and to use the default instead. - - """ - if not config_id: - raise RequiredArgument( - function=( - self.modify_scan_config_set_scanner_preference.__name__ - ), - argument="config_id", - ) - - if not name: - raise RequiredArgument( - function=( - self.modify_scan_config_set_scanner_preference.__name__ - ), - argument="name argument", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - - _xmlpref = cmd.add_element("preference") - - _xmlpref.add_element("name", name) - - if value: - _xmlpref.add_element("value", to_base64(value)) - - return self._send_xml_command(cmd) - - def modify_scan_config_set_nvt_selection( - self, config_id: str, family: str, nvt_oids: List[str] - ) -> Any: - """Modifies the selected nvts of an existing scan config - - The manager updates the given family in the config to include only the - given NVTs. - - Arguments: - config_id: UUID of scan config to modify. - family: Name of the NVT family to include NVTs from - nvt_oids: List of NVTs to select for the family. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config_set_nvt_selection.__name__, - argument="config_id", - ) - - if not family: - raise RequiredArgument( - function=self.modify_scan_config_set_nvt_selection.__name__, - argument="family argument", - ) - - if not is_list_like(nvt_oids): - raise InvalidArgumentType( - function=self.modify_scan_config_set_nvt_selection.__name__, - argument="nvt_oids", - arg_type="list", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - - _xmlnvtsel = cmd.add_element("nvt_selection") - _xmlnvtsel.add_element("family", family) - - for nvt in nvt_oids: - _xmlnvtsel.add_element("nvt", attrs={"oid": nvt}) - - return self._send_xml_command(cmd) - - def modify_scan_config_set_family_selection( - self, - config_id: str, - families: List[Tuple[str, bool, bool]], - *, - auto_add_new_families: Optional[bool] = True, - ) -> Any: - """ - Selected the NVTs of a scan config at a family level. - - Arguments: - config_id: UUID of scan config to modify. - families: A list of tuples (str, bool, bool): - str: the name of the NVT family selected, - bool: add new NVTs to the family automatically, - bool: include all NVTs from the family - auto_add_new_families: Whether new families should be added to the - scan config automatically. Default: True. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config_set_family_selection.__name__, - argument="config_id", - ) - - if not is_list_like(families): - raise InvalidArgumentType( - function=self.modify_scan_config_set_family_selection.__name__, - argument="families", - arg_type="list", - ) - - cmd = XmlCommand("modify_config") - cmd.set_attribute("config_id", str(config_id)) - - _xmlfamsel = cmd.add_element("family_selection") - _xmlfamsel.add_element("growing", to_bool(auto_add_new_families)) - - for family in families: - _xmlfamily = _xmlfamsel.add_element("family") - _xmlfamily.add_element("name", family[0]) - - if len(family) != 3: - raise InvalidArgument( - "Family must be a tuple of 3. (str, bool, bool)" - ) - - if not isinstance(family[1], bool) or not isinstance( - family[2], bool - ): - raise InvalidArgumentType( - function=( - self.modify_scan_config_set_family_selection.__name__ - ), - argument="families", - arg_type="[tuple(str, bool, bool)]", - ) - - _xmlfamily.add_element("all", to_bool(family[2])) - _xmlfamily.add_element("growing", to_bool(family[1])) - - return self._send_xml_command(cmd) - - def modify_scan_config( - self, config_id: str, selection: Optional[str] = None, **kwargs - ) -> Any: - """Modifies an existing scan config. - - DEPRECATED. Please use *modify_scan_config_set_* methods instead. - - modify_config has four modes to operate depending on the selection. - - Arguments: - config_id: UUID of scan config to modify. - selection: one of 'scan_pref', 'nvt_pref', 'nvt_selection' or - 'family_selection' - name: New name for preference. - value: New value for preference. - nvt_oids: List of NVTs associated with preference to modify. - family: Name of family to modify. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not config_id: - raise RequiredArgument( - function=self.modify_scan_config.__name__, - argument="config_id argument", - ) - - if selection is None: - deprecation( - "Using modify_config to update the comment of a scan config is" - "deprecated. Please use modify_scan_config_set_comment instead." - ) - return self.modify_scan_config_set_comment( - config_id, comment=kwargs.get("comment") - ) - - if selection not in ( - "nvt_pref", - "scan_pref", - "family_selection", - "nvt_selection", - ): - raise InvalidArgument( - "selection must be one of nvt_pref, " - "scan_pref, family_selection or " - "nvt_selection" - ) - - if selection == "nvt_pref": - deprecation( - "Using modify_scan_config to update a nvt preference of a scan " - "config is deprecated. Please use " - "modify_scan_config_set_nvt_preference instead." - ) - return self.modify_scan_config_set_nvt_preference( - config_id, **kwargs - ) - - if selection == "scan_pref": - deprecation( - "Using modify_scan_config to update a scanner preference of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_scanner_preference instead." - ) - return self.modify_scan_config_set_scanner_preference( - config_id, **kwargs - ) - - if selection == "nvt_selection": - deprecation( - "Using modify_scan_config to update a nvt selection of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_nvt_selection instead." - ) - return self.modify_scan_config_set_nvt_selection( - config_id, **kwargs - ) - - deprecation( - "Using modify_scan_config to update a family selection of a " - "scan config is deprecated. Please use " - "modify_scan_config_set_family_selection instead." - ) - return self.modify_scan_config_set_family_selection(config_id, **kwargs) - - def sync_scan_config(self) -> Any: - """Request an OSP config synchronization with scanner - - Returns: - The response. See :py:meth:`send_command` for details. - """ - return self._send_xml_command(XmlCommand("sync_config")) diff --git a/gvm/protocols/gmpv208/entities/secinfo.py b/gvm/protocols/gmpv208/entities/secinfo.py deleted file mode 100644 index 582718694..000000000 --- a/gvm/protocols/gmpv208/entities/secinfo.py +++ /dev/null @@ -1,620 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, Optional - -from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.utils import add_filter, to_bool -from gvm.xml import XmlCommand - - -class InfoType(Enum): - """Enum for info types""" - - CERT_BUND_ADV = "CERT_BUND_ADV" - CPE = "CPE" - CVE = "CVE" - DFN_CERT_ADV = "DFN_CERT_ADV" - OVALDEF = "OVALDEF" - NVT = "NVT" - - -class SecInfoMixin: - def get_nvt_families(self, *, sort_order: Optional[str] = None): - """Request a list of nvt families - - Arguments: - sort_order: Sort order - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_nvt_families") - - if sort_order: - cmd.set_attribute("sort_order", sort_order) - - return self._send_xml_command(cmd) - - def get_scan_config_nvts( - self, - *, - details: Optional[bool] = None, - preferences: Optional[bool] = None, - preference_count: Optional[bool] = None, - timeout: Optional[bool] = None, - config_id: Optional[str] = None, - preferences_config_id: Optional[str] = None, - family: Optional[str] = None, - sort_order: Optional[str] = None, - sort_field: Optional[str] = None, - ): - """Request a list of nvts - - Arguments: - details: Whether to include full details - preferences: Whether to include nvt preferences - preference_count: Whether to include preference count - timeout: Whether to include the special timeout preference - config_id: UUID of scan config to which to limit the NVT listing - preferences_config_id: UUID of scan config to use for preference - values - family: Family to which to limit NVT listing - sort_order: Sort order - sort_field: Sort field - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_nvts") - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - if preferences is not None: - cmd.set_attribute("preferences", to_bool(preferences)) - - if preference_count is not None: - cmd.set_attribute("preference_count", to_bool(preference_count)) - - if timeout is not None: - cmd.set_attribute("timeout", to_bool(timeout)) - - if config_id: - cmd.set_attribute("config_id", config_id) - - if preferences_config_id: - cmd.set_attribute("preferences_config_id", preferences_config_id) - - if family: - cmd.set_attribute("family", family) - - if sort_order: - cmd.set_attribute("sort_order", sort_order) - - if sort_field: - cmd.set_attribute("sort_field", sort_field) - - return self._send_xml_command(cmd) - - def get_scan_config_nvt(self, nvt_oid: str): - """Request a single nvt - - Arguments: - nvt_oid: OID of an existing nvt - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_nvts") - - if not nvt_oid: - raise RequiredArgument( - function=self.get_scan_config_nvt.__name__, argument="nvt_oid" - ) - - cmd.set_attribute("nvt_oid", nvt_oid) - - # for single entity always request all details - cmd.set_attribute("details", "1") - cmd.set_attribute("preferences", "1") - cmd.set_attribute("preference_count", "1") - return self._send_xml_command(cmd) - - def get_cves( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of CVEs - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info_list( - info_type=InfoType.CVE, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def get_cpes( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of CPEs - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info_list( - info_type=InfoType.CPE, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def get_nvts( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - extended: Optional[bool] = None, - preferences: Optional[bool] = None, - preference_count: Optional[bool] = None, - timeout: Optional[bool] = None, - config_id: Optional[str] = None, - preferences_config_id: Optional[str] = None, - family: Optional[str] = None, - sort_order: Optional[str] = None, - sort_field: Optional[str] = None, - ) -> Any: - """Request a list of NVTs - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - extended: Whether to receive extended NVT information - (calls get_nvts, instead of get_info) - preferences: Whether to include NVT preferences - preference_count: Whether to include preference count - timeout: Whether to include the special timeout preference - config_id: UUID of scan config to which to limit the NVT listing - preferences_config_id: UUID of scan config to use for preference - values - family: Family to which to limit NVT listing - sort_order: Sort order - sort_field: Sort field - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - if extended: - return self._get_nvt_details( - details=details, - preferences=preferences, - preference_count=preference_count, - timeout=timeout, - config_id=config_id, - preferences_config_id=preferences_config_id, - family=family, - sort_order=sort_order, - sort_field=sort_field, - ) - - return self.get_info_list( - info_type=InfoType.NVT, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def _get_nvt_details( - self, - *, - details: Optional[bool] = None, - preferences: Optional[bool] = None, - preference_count: Optional[bool] = None, - timeout: Optional[bool] = None, - config_id: Optional[str] = None, - preferences_config_id: Optional[str] = None, - family: Optional[str] = None, - sort_order: Optional[str] = None, - sort_field: Optional[str] = None, - ): - """Request a list of NVTs with extended details - Arguments: - details: Whether to include full details - preferences: Whether to include nvt preferences - preference_count: Whether to include preference count - timeout: Whether to include the special timeout preference - config_id: UUID of scan config to which to limit the NVT listing - preferences_config_id: UUID of scan config to use for preference - values - family: Family to which to limit NVT listing - sort_order: Sort order - sort_field: Sort field - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_nvts") - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - if preferences is not None: - cmd.set_attribute("preferences", to_bool(preferences)) - - if preference_count is not None: - cmd.set_attribute("preference_count", to_bool(preference_count)) - - if timeout is not None: - cmd.set_attribute("timeout", to_bool(timeout)) - - if config_id: - cmd.set_attribute("config_id", config_id) - - if preferences_config_id: - cmd.set_attribute("preferences_config_id", preferences_config_id) - - if family: - cmd.set_attribute("family", family) - - if sort_order: - cmd.set_attribute("sort_order", sort_order) - - if sort_field: - cmd.set_attribute("sort_field", sort_field) - - return self._send_xml_command(cmd) - - def get_dfn_cert_advisories( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of DFN-CERT Advisories - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info_list( - info_type=InfoType.DFN_CERT_ADV, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def get_cert_bund_advisories( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of CERT-BUND Advisories - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info_list( - info_type=InfoType.CERT_BUND_ADV, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def get_oval_definitions( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of OVAL definitions - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info_list( - info_type=InfoType.OVALDEF, - filter_string=filter_string, - filter_id=filter_id, - name=name, - details=details, - ) - - def get_info_list( - self, - info_type: InfoType, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - name: Optional[str] = None, - details: Optional[bool] = None, - ) -> Any: - """Request a list of security information - - Arguments: - info_type: Type must be either CERT_BUND_ADV, CPE, CVE, - DFN_CERT_ADV, OVALDEF or NVT - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - name: Name or identifier of the requested information - details: Whether to include information about references to this - information - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not info_type: - raise RequiredArgument( - function=self.get_info_list.__name__, argument="info_type" - ) - - if not isinstance(info_type, InfoType): - raise InvalidArgumentType( - function=self.get_info_list.__name__, - argument="info_type", - arg_type=InfoType.__name__, - ) - - cmd = XmlCommand("get_info") - - cmd.set_attribute("type", info_type.value) - - add_filter(cmd, filter_string, filter_id) - - if name: - cmd.set_attribute("name", name) - - if details is not None: - cmd.set_attribute("details", to_bool(details)) - - return self._send_xml_command(cmd) - - def get_cve(self, cve_id: str) -> Any: - """Request a single CVE - - Arguments: - cve_id: ID of an existing CVE - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info(cve_id, InfoType.CVE) - - def get_cpe(self, cpe_id: str) -> Any: - """Request a single CPE - - Arguments: - cpe_id: ID of an existing CPE - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info(cpe_id, InfoType.CPE) - - def get_nvt(self, nvt_id: str, *, extended: Optional[bool] = None) -> Any: - """Request a single NVT - - Arguments: - nvt_id: ID of an existing NVT - extended: Whether to receive extended NVT information - (calls get_nvts, instead of get_info) - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - if extended: - cmd = XmlCommand("get_nvts") - - if not nvt_id: - raise RequiredArgument( - function=self.get_nvt.__name__, argument="nvt_oid" - ) - - cmd.set_attribute("nvt_oid", nvt_id) - - # for single entity always request all details - cmd.set_attribute("details", "1") - cmd.set_attribute("preferences", "1") - cmd.set_attribute("preference_count", "1") - return self._send_xml_command(cmd) - - return self.get_info(nvt_id, InfoType.NVT) - - def get_dfn_cert_advisory(self, cert_id: str) -> Any: - """Request a single DFN-CERT Advisory - - Arguments: - cert_id: ID of an existing DFN-CERT Advisory - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info(cert_id, InfoType.DFN_CERT_ADV) - - def get_cert_bund_advisory(self, cert_id: str) -> Any: - """Request a single CERT-BUND Advisory - - Arguments: - cert_id: ID of an existing CERT-BUND Advisory - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info(cert_id, InfoType.CERT_BUND_ADV) - - def get_oval_definition(self, oval_id: str) -> Any: - """Request a single Oval definition - - Arguments: - oval_id: ID of an existing Oval definition - - Returns: - The response. See :py:meth:`send_command` for details. - """ - - return self.get_info(oval_id, InfoType.OVALDEF) - - def get_info(self, info_id: str, info_type: InfoType) -> Any: - """Request a single secinfo - - Arguments: - info_id: ID of an existing secinfo - info_type: Type must be either CERT_BUND_ADV, CPE, CVE, - DFN_CERT_ADV, OVALDEF, NVT - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not info_type: - raise RequiredArgument( - function=self.get_info.__name__, argument="info_type" - ) - - if not isinstance(info_type, InfoType): - raise InvalidArgumentType( - function=self.get_info.__name__, - argument="info_type", - arg_type=InfoType.__name__, - ) - - if not info_id: - raise RequiredArgument( - function=self.get_info.__name__, argument="info_id" - ) - - cmd = XmlCommand("get_info") - cmd.set_attribute("info_id", info_id) - - cmd.set_attribute("type", info_type.value) - - # for single entity always request all details - cmd.set_attribute("details", "1") - return self._send_xml_command(cmd) - - def get_nvt_preferences( - self, - *, - nvt_oid: Optional[str] = None, - ) -> Any: - """Request a list of preferences - - The preference element includes just the - name and value, with the NVT and type built into the name. - - Arguments: - nvt_oid: OID of nvt - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_preferences") - - if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) - - return self._send_xml_command(cmd) - - def get_nvt_preference( - self, - name: str, - *, - nvt_oid: Optional[str] = None, - ) -> Any: - """Request a nvt preference - - Arguments: - name: name of a particular preference - nvt_oid: OID of nvt - config_id: UUID of scan config of which to show preference values - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_preferences") - - if not name: - raise RequiredArgument( - function=self.get_nvt_preference.__name__, argument="name" - ) - - cmd.set_attribute("preference", name) - - if nvt_oid: - cmd.set_attribute("nvt_oid", nvt_oid) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/entities/users.py b/gvm/protocols/gmpv208/entities/users.py deleted file mode 100644 index 13cfa036e..000000000 --- a/gvm/protocols/gmpv208/entities/users.py +++ /dev/null @@ -1,278 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional - -from gvm._enum import Enum -from gvm.errors import RequiredArgument -from gvm.utils import add_filter, to_bool, to_comma_list -from gvm.xml import XmlCommand - - -class UserAuthType(Enum): - """Enum for Sources allowed for authentication for the user""" - - FILE = "file" - LDAP_CONNECT = "ldap_connect" - RADIUS_CONNECT = "radius_connect" - - -class UsersMixin: - def clone_user(self, user_id: str) -> Any: - """Clone an existing user - - Arguments: - user_id: UUID of existing user to clone from - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not user_id: - raise RequiredArgument( - function=self.clone_user.__name__, argument="user_id" - ) - - cmd = XmlCommand("create_user") - cmd.add_element("copy", user_id) - return self._send_xml_command(cmd) - - def create_user( - self, - name: str, - *, - password: Optional[str] = None, - hosts: Optional[List[str]] = None, - hosts_allow: Optional[bool] = False, - ifaces: Optional[List[str]] = None, - ifaces_allow: Optional[bool] = False, - role_ids: Optional[List[str]] = None, - ) -> Any: - """Create a new user - - Arguments: - name: Name of the user - password: Password of the user - hosts: A list of host addresses (IPs, DNS names) - hosts_allow: If True allow only access to passed hosts otherwise - deny access. Default is False for deny hosts. - ifaces: A list of interface names - ifaces_allow: If True allow only access to passed interfaces - otherwise deny access. Default is False for deny interfaces. - role_ids: A list of role UUIDs for the user - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_user.__name__, argument="name" - ) - - cmd = XmlCommand("create_user") - cmd.add_element("name", name) - - if password: - cmd.add_element("password", password) - - if hosts: - cmd.add_element( - "hosts", - to_comma_list(hosts), - attrs={"allow": to_bool(hosts_allow)}, - ) - - if ifaces: - cmd.add_element( - "ifaces", - to_comma_list(ifaces), - attrs={"allow": to_bool(ifaces_allow)}, - ) - - if role_ids: - for role in role_ids: - cmd.add_element("role", attrs={"id": role}) - - return self._send_xml_command(cmd) - - def delete_user( - self, - user_id: str = None, - *, - name: Optional[str] = None, - inheritor_id: Optional[str] = None, - inheritor_name: Optional[str] = None, - ) -> Any: - """Deletes an existing user - - Either user_id or name must be passed. - - Arguments: - user_id: UUID of the task to be deleted. - name: The name of the user to be deleted. - inheritor_id: The ID of the inheriting user or "self". Overrides - inheritor_name. - inheritor_name: The name of the inheriting user. - - """ - if not user_id and not name: - raise RequiredArgument( - function=self.delete_user.__name__, argument="user_id or name" - ) - - cmd = XmlCommand("delete_user") - - if user_id: - cmd.set_attribute("user_id", user_id) - - if name: - cmd.set_attribute("name", name) - - if inheritor_id: - cmd.set_attribute("inheritor_id", inheritor_id) - if inheritor_name: - cmd.set_attribute("inheritor_name", inheritor_name) - - return self._send_xml_command(cmd) - - def get_users( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - ) -> Any: - """Request a list of users - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_users") - - add_filter(cmd, filter_string, filter_id) - - return self._send_xml_command(cmd) - - def get_user(self, user_id: str) -> Any: - """Request a single user - - Arguments: - user_id: UUID of an existing user - - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_users") - - if not user_id: - raise RequiredArgument( - function=self.get_user.__name__, argument="user_id" - ) - - cmd.set_attribute("user_id", user_id) - return self._send_xml_command(cmd) - - def modify_user( - self, - user_id: str = None, - name: str = None, - *, - new_name: Optional[str] = None, - comment: Optional[str] = None, - password: Optional[str] = None, - auth_source: Optional[UserAuthType] = None, - role_ids: Optional[List[str]] = None, - hosts: Optional[List[str]] = None, - hosts_allow: Optional[bool] = False, - ifaces: Optional[List[str]] = None, - ifaces_allow: Optional[bool] = False, - group_ids: Optional[List[str]] = None, - ) -> Any: - """Modifies an existing user. - - Most of the fields need to be supplied - for changing a single field even if no change is wanted for those. - Else empty values are inserted for the missing fields instead. - - Arguments: - user_id: UUID of the user to be modified. Overrides name element - argument. - name: The name of the user to be modified. Either user_id or name - must be passed. - new_name: The new name for the user. - comment: Comment on the user. - password: The password for the user. - auth_source: Source allowed for authentication for this user. - roles_id: List of roles UUIDs for the user. - hosts: User access rules: List of hosts. - hosts_allow: Defines how the hosts list is to be interpreted. - If False (default) the list is treated as a deny list. - All hosts are allowed by default except those provided by - the hosts parameter. If True the list is treated as a - allow list. All hosts are denied by default except those - provided by the hosts parameter. - ifaces: User access rules: List of ifaces. - ifaces_allow: Defines how the ifaces list is to be interpreted. - If False (default) the list is treated as a deny list. - All ifaces are allowed by default except those provided by - the ifaces parameter. If True the list is treated as a - allow list. All ifaces are denied by default except those - provided by the ifaces parameter. - group_ids: List of group UUIDs for the user. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not user_id and not name: - raise RequiredArgument( - function=self.modify_user.__name__, argument="user_id or name" - ) - - cmd = XmlCommand("modify_user") - - if user_id: - cmd.set_attribute("user_id", user_id) - else: - cmd.add_element("name", name) - - if new_name: - cmd.add_element("new_name", new_name) - - if role_ids: - for role in role_ids: - cmd.add_element("role", attrs={"id": role}) - - if hosts: - cmd.add_element( - "hosts", - to_comma_list(hosts), - attrs={"allow": to_bool(hosts_allow)}, - ) - - if ifaces: - cmd.add_element( - "ifaces", - to_comma_list(ifaces), - attrs={"allow": to_bool(ifaces_allow)}, - ) - - if comment: - cmd.add_element("comment", comment) - - if password: - cmd.add_element("password", password) - - if auth_source: - _xmlauthsrc = cmd.add_element("sources") - _xmlauthsrc.add_element("source", auth_source.value) - - if group_ids: - _xmlgroups = cmd.add_element("groups") - for group_id in group_ids: - _xmlgroups.add_element("group", attrs={"id": group_id}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/entities/vulnerabilities.py b/gvm/protocols/gmpv208/entities/vulnerabilities.py deleted file mode 100644 index 199882500..000000000 --- a/gvm/protocols/gmpv208/entities/vulnerabilities.py +++ /dev/null @@ -1,51 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, Optional - -from gvm.errors import RequiredArgument -from gvm.utils import add_filter -from gvm.xml import XmlCommand - - -class VulnerabilitiesMixin: - def get_vulnerabilities( - self, - *, - filter_string: Optional[str] = None, - filter_id: Optional[str] = None, - ) -> Any: - """Request a list of vulnerabilities - - Arguments: - filter_string: Filter term to use for the query - filter_id: UUID of an existing filter to use for the query - Returns: - The response. See :py:meth:`send_command` for details. - """ - cmd = XmlCommand("get_vulns") - - add_filter(cmd, filter_string, filter_id) - - return self._send_xml_command(cmd) - - def get_vulnerability(self, vulnerability_id: str) -> Any: - """Request a single vulnerability - - Arguments: - vulnerability_id: ID of an existing vulnerability - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not vulnerability_id: - raise RequiredArgument( - function=self.get_vulnerability.__name__, - argument="vulnerability_id", - ) - - cmd = XmlCommand("get_vulns") - cmd.set_attribute("vuln_id", vulnerability_id) - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/system/__init__.py b/gvm/protocols/gmpv208/system/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv208/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv208/system/authentication.py b/gvm/protocols/gmpv208/system/authentication.py deleted file mode 100644 index 7a25d504c..000000000 --- a/gvm/protocols/gmpv208/system/authentication.py +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any - -from gvm.errors import RequiredArgument -from gvm.utils import check_command_status -from gvm.xml import XmlCommand - - -class AuthenticationMixin: - def is_authenticated(self) -> bool: - """Checks if the user is authenticated - - If the user is authenticated privileged GMP commands like get_tasks - may be send to gvmd. - - Returns: - bool: True if an authenticated connection to gvmd has been - established. - """ - return self._authenticated - - def authenticate(self, username: str, password: str) -> Any: - """Authenticate to gvmd. - - The generated authenticate command will be send to server. - Afterwards the response is read, transformed and returned. - - Arguments: - username: Username - password: Password - - Returns: - Transformed response from server. - """ - cmd = XmlCommand("authenticate") - - if not username: - raise RequiredArgument( - function=self.authenticate.__name__, argument="username" - ) - - if not password: - raise RequiredArgument( - function=self.authenticate.__name__, argument="password" - ) - - credentials = cmd.add_element("credentials") - credentials.add_element("username", username) - credentials.add_element("password", password) - - self._send(cmd.to_string()) - response = self._read() - - if check_command_status(response): - self._authenticated = True - - return self._transform(response) - - def describe_auth(self) -> Any: - """Describe authentication methods - - Returns a list of all used authentication methods if such a list is - available. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - return self._send_xml_command(XmlCommand("describe_auth")) - - def modify_auth(self, group_name: str, auth_conf_settings: dict) -> Any: - """Modifies an existing auth. - - Arguments: - group_name: Name of the group to be modified. - auth_conf_settings: The new auth config. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not group_name: - raise RequiredArgument( - function=self.modify_auth.__name__, argument="group_name" - ) - if not auth_conf_settings: - raise RequiredArgument( - function=self.modify_auth.__name__, - argument="auth_conf_settings", - ) - cmd = XmlCommand("modify_auth") - _xmlgroup = cmd.add_element("group", attrs={"name": str(group_name)}) - - for key, value in auth_conf_settings.items(): - _xmlauthconf = _xmlgroup.add_element("auth_conf_setting") - _xmlauthconf.add_element("key", key) - _xmlauthconf.add_element("value", value) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/system/feed.py b/gvm/protocols/gmpv208/system/feed.py deleted file mode 100644 index 42ce3a76d..000000000 --- a/gvm/protocols/gmpv208/system/feed.py +++ /dev/null @@ -1,55 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, Optional - -from gvm._enum import Enum -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.xml import XmlCommand - - -class FeedType(Enum): - """Enum for feed types""" - - NVT = "NVT" - CERT = "CERT" - SCAP = "SCAP" - GVMD_DATA = "GVMD_DATA" - - -class FeedMixin: - def get_feeds(self) -> Any: - """Request the list of feeds - - Returns: - The response. See :py:meth:`send_command` for details. - """ - return self._send_xml_command(XmlCommand("get_feeds")) - - def get_feed(self, feed_type: Optional[FeedType]) -> Any: - """Request a single feed - - Arguments: - feed_type: Type of single feed to get: NVT, CERT or SCAP - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not feed_type: - raise RequiredArgument( - function=self.get_feed.__name__, argument="feed_type" - ) - - if not isinstance(feed_type, FeedType): - raise InvalidArgumentType( - function=self.get_feed.__name__, - argument="feed_type", - arg_type=FeedType.__name__, - ) - - cmd = XmlCommand("get_feeds") - cmd.set_attribute("type", feed_type.value) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/system/trashcan.py b/gvm/protocols/gmpv208/system/trashcan.py deleted file mode 100644 index 1ec0b9e6b..000000000 --- a/gvm/protocols/gmpv208/system/trashcan.py +++ /dev/null @@ -1,42 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any - -from gvm.errors import RequiredArgument -from gvm.xml import XmlCommand - - -class TrashcanMixin: - def empty_trashcan(self) -> Any: - """Empty the trashcan - - Remove all entities from the trashcan. **Attention:** this command can - not be reverted - - Returns: - The response. See :py:meth:`send_command` for details. - """ - return self._send_xml_command(XmlCommand("empty_trashcan")) - - def restore_from_trashcan(self, entity_id: str) -> Any: - """Restore an entity from the trashcan - - Arguments: - entity_id: ID of the entity to be restored from the trashcan - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not entity_id: - raise RequiredArgument( - function=self.restore_from_trashcan.__name__, - argument="entity_id", - ) - - cmd = XmlCommand("restore") - cmd.set_attribute("id", entity_id) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv208/system/version.py b/gvm/protocols/gmpv208/system/version.py deleted file mode 100644 index 105f1abb3..000000000 --- a/gvm/protocols/gmpv208/system/version.py +++ /dev/null @@ -1,31 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any - -from gvm.xml import XmlCommand - -PROTOCOL_VERSION = (20, 8) - - -class VersionMixin: - def get_version(self) -> Any: - """Get the Greenbone Vulnerability Manager Protocol version used - by the remote gvmd. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - return self._send_xml_command(XmlCommand("get_version")) - - @staticmethod - def get_protocol_version() -> tuple: - """Determine the Greenbone Management Protocol (gmp) version used - by python-gvm version. - - Returns: - tuple: Implemented version of the Greenbone Management Protocol - """ - return PROTOCOL_VERSION diff --git a/gvm/protocols/gmpv214/__init__.py b/gvm/protocols/gmpv214/__init__.py deleted file mode 100644 index 57b559f2a..000000000 --- a/gvm/protocols/gmpv214/__init__.py +++ /dev/null @@ -1,187 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=too-many-lines,redefined-builtin - -""" -Module for communication with gvmd in -`Greenbone Management Protocol version 21.04`_ - -.. _Greenbone Management Protocol version 21.04: - https://docs.greenbone.net/API/GMP/gmp-21.04.html -""" - -import logging -from typing import Any, Callable, Optional - -from gvm.connections import GvmConnection -from gvm.protocols.base import GvmProtocol -from gvm.protocols.gmpv208.entities.alerts import ( - AlertCondition, - AlertEvent, - AlertMethod, - AlertsMixin, -) -from gvm.protocols.gmpv208.entities.audits import AuditsMixin -from gvm.protocols.gmpv208.entities.credentials import ( - CredentialFormat, - CredentialsMixin, - CredentialType, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, -) -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.protocols.gmpv208.entities.filter import FiltersMixin, FilterType -from gvm.protocols.gmpv208.entities.groups import GroupsMixin -from gvm.protocols.gmpv208.entities.hosts import HostsMixin, HostsOrdering -from gvm.protocols.gmpv208.entities.operating_systems import ( - OperatingSystemsMixin, -) -from gvm.protocols.gmpv208.entities.permissions import ( - PermissionsMixin, - PermissionSubjectType, -) -from gvm.protocols.gmpv208.entities.policies import PoliciesMixin -from gvm.protocols.gmpv208.entities.port_lists import ( - PortListMixin, - PortRangeType, -) -from gvm.protocols.gmpv208.entities.report_formats import ( - ReportFormatsMixin, - ReportFormatType, -) -from gvm.protocols.gmpv208.entities.reports import ReportsMixin -from gvm.protocols.gmpv208.entities.results import ResultsMixin -from gvm.protocols.gmpv208.entities.roles import RolesMixin -from gvm.protocols.gmpv208.entities.scan_configs import ScanConfigsMixin -from gvm.protocols.gmpv208.entities.schedules import SchedulesMixin -from gvm.protocols.gmpv208.entities.secinfo import InfoType, SecInfoMixin -from gvm.protocols.gmpv208.entities.severity import SeverityLevel -from gvm.protocols.gmpv208.entities.tags import TagsMixin -from gvm.protocols.gmpv208.entities.tasks import TasksMixin -from gvm.protocols.gmpv208.entities.tickets import TicketsMixin, TicketStatus -from gvm.protocols.gmpv208.entities.tls_certificates import TLSCertificateMixin -from gvm.protocols.gmpv208.entities.users import UserAuthType -from gvm.protocols.gmpv208.entities.vulnerabilities import VulnerabilitiesMixin -from gvm.protocols.gmpv208.system.aggregates import ( - AggregatesMixin, - AggregateStatistic, - SortOrder, -) -from gvm.protocols.gmpv208.system.authentication import AuthenticationMixin -from gvm.protocols.gmpv208.system.feed import FeedMixin, FeedType -from gvm.protocols.gmpv208.system.help import HelpFormat, HelpMixin -from gvm.protocols.gmpv208.system.system_reports import SystemReportsMixin -from gvm.protocols.gmpv208.system.trashcan import TrashcanMixin -from gvm.protocols.gmpv208.system.user_settings import UserSettingsMixin - -# NEW IN 214 -from gvm.protocols.gmpv214.entities.notes import NotesMixin -from gvm.protocols.gmpv214.entities.overrides import OverridesMixin -from gvm.protocols.gmpv214.entities.scanners import ScannersMixin, ScannerType -from gvm.protocols.gmpv214.entities.targets import AliveTest, TargetsMixin -from gvm.protocols.gmpv214.entities.users import UsersMixin -from gvm.protocols.gmpv214.system.version import VersionMixin -from gvm.utils import to_dotted_types_dict - -logger = logging.getLogger(__name__) - -_TYPE_FIELDS = [ - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - HostsOrdering, - InfoType, - HelpFormat, - PortRangeType, - PermissionSubjectType, - ReportFormatType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, -] - - -class Gmp( - GvmProtocol, - AggregatesMixin, - AlertsMixin, - AuditsMixin, - AuthenticationMixin, - CredentialsMixin, - FeedMixin, - FiltersMixin, - GroupsMixin, - HelpMixin, - HostsMixin, - NotesMixin, - OperatingSystemsMixin, - OverridesMixin, - PermissionsMixin, - PoliciesMixin, - PortListMixin, - ReportFormatsMixin, - ReportsMixin, - ResultsMixin, - RolesMixin, - TagsMixin, - TargetsMixin, - TasksMixin, - TicketsMixin, - TLSCertificateMixin, - TrashcanMixin, - ScanConfigsMixin, - ScannersMixin, - SchedulesMixin, - SecInfoMixin, - SystemReportsMixin, - UserSettingsMixin, - UsersMixin, - VersionMixin, - VulnerabilitiesMixin, -): - """Python interface for Greenbone Management Protocol - - This class implements the `Greenbone Management Protocol version 21.04`_ - - Arguments: - connection: Connection to use to talk with the gvmd daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - - .. _Greenbone Management Protocol version 21.04: - https://docs.greenbone.net/API/GMP/gmp-21.04.html - .. _callable: - https://docs.python.org/3/library/functions.html#callable - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - self.types = to_dotted_types_dict(_TYPE_FIELDS) - - super().__init__(connection, transform=transform) - - # Is authenticated on gvmd - self._authenticated = False diff --git a/gvm/protocols/gmpv214/entities/__init__.py b/gvm/protocols/gmpv214/entities/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv214/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv214/entities/notes.py b/gvm/protocols/gmpv214/entities/notes.py deleted file mode 100644 index d0f07d8a5..000000000 --- a/gvm/protocols/gmpv214/entities/notes.py +++ /dev/null @@ -1,167 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv208.entities.notes import NotesMixin as Gmp208NotesMixin -from gvm.protocols.gmpv208.entities.severity import Severity -from gvm.utils import check_port, deprecation, to_comma_list -from gvm.xml import XmlCommand - - -class NotesMixin(Gmp208NotesMixin): - def create_note( - self, - text: str, - nvt_oid: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[int] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Any = None, - ) -> Any: - """Create a new note - - Arguments: - text: Text of the new note - nvt_id: OID of the nvt to which note applies - days_active: Days note will be active. -1 on - always, 0 off - hosts: A list of hosts addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: UUID of a result to which note applies - severity: Severity to which note applies - task_id: UUID of task to which note applies - threat: deprecated - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not text: - raise RequiredArgument( - function=self.create_note.__name__, argument="text" - ) - - if not nvt_oid: - raise RequiredArgument( - function=self.create_note.__name__, argument="nvt_oid" - ) - - cmd = XmlCommand("create_note") - cmd.add_element("text", text) - cmd.add_element("nvt", attrs={"oid": nvt_oid}) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.create_note.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - return self._send_xml_command(cmd) - - def modify_note( - self, - note_id: str, - text: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[int] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Any = None, - ) -> Any: - """Modifies an existing note. - - Arguments: - note_id: UUID of note to modify. - text: The text of the note. - days_active: Days note will be active. -1 on always, 0 off. - hosts: A list of hosts addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: Result to which note applies. - severity: Severity to which note applies. - task_id: Task to which note applies. - threat: deprecated - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not note_id: - raise RequiredArgument( - function=self.modify_note.__name__, argument="note_id" - ) - - if not text: - raise RequiredArgument( - function=self.modify_note.__name__, argument="text" - ) - - cmd = XmlCommand("modify_note") - cmd.set_attribute("note_id", note_id) - cmd.add_element("text", text) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.modify_note.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv214/entities/overrides.py b/gvm/protocols/gmpv214/entities/overrides.py deleted file mode 100644 index 1aad3fbce..000000000 --- a/gvm/protocols/gmpv214/entities/overrides.py +++ /dev/null @@ -1,196 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from typing import Any, List, Optional - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv208.entities.overrides import ( - OverridesMixin as Gmp208OverridesMixin, -) -from gvm.protocols.gmpv208.entities.severity import Severity -from gvm.utils import check_port, deprecation, to_comma_list -from gvm.xml import XmlCommand - - -class OverridesMixin(Gmp208OverridesMixin): - def create_override( - self, - text: str, - nvt_oid: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[str] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - new_severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Any = None, - new_threat: Any = None, - ) -> Any: - """Create a new override - - Arguments: - text: Text of the new override - nvt_id: OID of the nvt to which override applies - days_active: Days override will be active. -1 on always, 0 off - hosts: A list of host addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: UUID of a result to which override applies - severity: Severity to which override applies - new_severity: New severity for result - task_id: UUID of task to which override applies - threat: deprecated - new_threat: deprecated - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not text: - raise RequiredArgument( - function=self.create_override.__name__, argument="text" - ) - - if not nvt_oid: - raise RequiredArgument( - function=self.create_override.__name__, argument="nvt_oid" - ) - - cmd = XmlCommand("create_override") - cmd.add_element("text", text) - cmd.add_element("nvt", attrs={"oid": nvt_oid}) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.create_override.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if new_severity is not None: - cmd.add_element("new_severity", str(new_severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if new_threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The new_threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - return self._send_xml_command(cmd) - - def modify_override( - self, - override_id: str, - text: str, - *, - days_active: Optional[int] = None, - hosts: Optional[List[str]] = None, - port: Optional[str] = None, - result_id: Optional[str] = None, - severity: Optional[Severity] = None, - new_severity: Optional[Severity] = None, - task_id: Optional[str] = None, - threat: Any = None, - new_threat: Any = None, - ) -> Any: - """Modifies an existing override. - - Arguments: - override_id: UUID of override to modify. - text: The text of the override. - days_active: Days override will be active. -1 on always, - 0 off. - hosts: A list of host addresses - port: Port to which the override applies, needs to be a string - in the form {number}/{protocol} - result_id: Result to which override applies. - severity: Severity to which override applies. - new_severity: New severity score for result. - task_id: Task to which override applies. - threat: deprecated - new_threat: deprecated - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not override_id: - raise RequiredArgument( - function=self.modify_override.__name__, argument="override_id" - ) - if not text: - raise RequiredArgument( - function=self.modify_override.__name__, argument="text" - ) - - cmd = XmlCommand("modify_override") - cmd.set_attribute("override_id", override_id) - cmd.add_element("text", text) - - if days_active is not None: - cmd.add_element("active", str(days_active)) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - - if port: - if check_port(port): - cmd.add_element("port", str(port)) - else: - raise InvalidArgument( - function=self.modify_override.__name__, argument="port" - ) - - if result_id: - cmd.add_element("result", attrs={"id": result_id}) - - if severity is not None: - cmd.add_element("severity", str(severity)) - - if new_severity is not None: - cmd.add_element("new_severity", str(new_severity)) - - if task_id: - cmd.add_element("task", attrs={"id": task_id}) - - if threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if new_threat is not None: - major, minor = self.get_protocol_version() - deprecation( - "The new_threat parameter has been removed in GMP" - f" version {major}{minor}" - ) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv214/entities/scanners.py b/gvm/protocols/gmpv214/entities/scanners.py deleted file mode 100644 index 47845d6da..000000000 --- a/gvm/protocols/gmpv214/entities/scanners.py +++ /dev/null @@ -1,204 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -from enum import Enum -from typing import Any, Optional - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.scanners import ( - ScannersMixin as Gmp208ScannersMixin, -) -from gvm.xml import XmlCommand - - -class ScannerType(Enum): - """Enum for scanner type""" - - OSP_SCANNER_TYPE = "1" - OPENVAS_SCANNER_TYPE = "2" - CVE_SCANNER_TYPE = "3" - GREENBONE_SENSOR_SCANNER_TYPE = "5" - - @classmethod - def from_string( - cls, - scanner_type: Optional[str], - ) -> Optional["ScannerType"]: - """Convert a scanner type string to an actual ScannerType instance - - Arguments: - scanner_type: Scanner type string to convert to a ScannerType - """ - if not scanner_type: - return None - - scanner_type = scanner_type.lower() - - if scanner_type == cls.OSP_SCANNER_TYPE.value or scanner_type == "osp": - return cls.OSP_SCANNER_TYPE - - if ( - scanner_type == cls.OPENVAS_SCANNER_TYPE.value - or scanner_type == "openvas" - ): - return cls.OPENVAS_SCANNER_TYPE - - if scanner_type == cls.CVE_SCANNER_TYPE.value or scanner_type == "cve": - return cls.CVE_SCANNER_TYPE - - if ( - scanner_type == cls.GREENBONE_SENSOR_SCANNER_TYPE.value - or scanner_type == "greenbone" - ): - return cls.GREENBONE_SENSOR_SCANNER_TYPE - - raise InvalidArgument( - argument="scanner_type", function=cls.from_string.__name__ - ) - - -class ScannersMixin(Gmp208ScannersMixin): - # Override bc. of ScannerType (?) - - def create_scanner( - self, - name: str, - host: str, - port: int, - scanner_type: ScannerType, - credential_id: str, - *, - ca_pub: Optional[str] = None, - comment: Optional[str] = None, - ) -> Any: - """Create a new scanner - - Arguments: - name: Name of the scanner - host: The host of the scanner - port: The port of the scanner - scanner_type: Type of the scanner. - credential_id: UUID of client certificate credential for the - scanner - ca_pub: Certificate of CA to verify scanner certificate - comment: Comment for the scanner - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="name" - ) - - if not host: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="host" - ) - - if not port: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="port" - ) - - if not scanner_type: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="scanner_type" - ) - - if not credential_id: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="credential_id" - ) - - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.create_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, - ) - - cmd = XmlCommand("create_scanner") - cmd.add_element("name", name) - cmd.add_element("host", host) - cmd.add_element("port", str(port)) - cmd.add_element("type", scanner_type.value) - - if ca_pub: - cmd.add_element("ca_pub", ca_pub) - - cmd.add_element("credential", attrs={"id": str(credential_id)}) - - if comment: - cmd.add_element("comment", comment) - - return self._send_xml_command(cmd) - - def modify_scanner( - self, - scanner_id: str, - *, - scanner_type: Optional[ScannerType] = None, - host: Optional[str] = None, - port: Optional[int] = None, - comment: Optional[str] = None, - name: Optional[str] = None, - ca_pub: Optional[str] = None, - credential_id: Optional[str] = None, - ) -> Any: - """Modifies an existing scanner. - - Arguments: - scanner_id: UUID of scanner to modify. - scanner_type: New type of the Scanner. - host: Host of the scanner. - port: Port of the scanner. - comment: Comment on scanner. - name: Name of scanner. - ca_pub: Certificate of CA to verify scanner's certificate. - credential_id: UUID of the client certificate credential for the - Scanner. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not scanner_id: - raise RequiredArgument( - function=self.modify_scanner.__name__, - argument="scanner_id argument", - ) - - cmd = XmlCommand("modify_scanner") - cmd.set_attribute("scanner_id", scanner_id) - - if scanner_type is not None: - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.modify_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, - ) - - cmd.add_element("type", scanner_type.value) - - if host: - cmd.add_element("host", host) - - if port: - cmd.add_element("port", str(port)) - - if comment: - cmd.add_element("comment", comment) - - if name: - cmd.add_element("name", name) - - if ca_pub: - cmd.add_element("ca_pub", ca_pub) - - if credential_id: - cmd.add_element("credential", attrs={"id": str(credential_id)}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv214/entities/targets.py b/gvm/protocols/gmpv214/entities/targets.py deleted file mode 100644 index 361e4b3c4..000000000 --- a/gvm/protocols/gmpv214/entities/targets.py +++ /dev/null @@ -1,245 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=arguments-differ, unused-import - -from typing import Any, List, Optional - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.targets import AliveTest -from gvm.protocols.gmpv208.entities.targets import ( - TargetsMixin as Gmp208TargetsMixin, -) -from gvm.utils import to_bool, to_comma_list -from gvm.xml import XmlCommand - - -class TargetsMixin(Gmp208TargetsMixin): - def create_target( - self, - name: str, - *, - asset_hosts_filter: Optional[str] = None, - hosts: Optional[List[str]] = None, - comment: Optional[str] = None, - exclude_hosts: Optional[List[str]] = None, - ssh_credential_id: Optional[str] = None, - ssh_credential_port: Optional[int] = None, - smb_credential_id: Optional[str] = None, - esxi_credential_id: Optional[str] = None, - snmp_credential_id: Optional[str] = None, - alive_test: Optional[AliveTest] = None, - allow_simultaneous_ips: Optional[bool] = None, - reverse_lookup_only: Optional[bool] = None, - reverse_lookup_unify: Optional[bool] = None, - port_range: Optional[str] = None, - port_list_id: Optional[str] = None, - ) -> Any: - """Create a new target - - Arguments: - name: Name of the target - asset_hosts_filter: Filter to select target host from assets hosts - hosts: List of hosts addresses to scan - exclude_hosts: List of hosts addresses to exclude from scan - comment: Comment for the target - ssh_credential_id: UUID of a ssh credential to use on target - ssh_credential_port: The port to use for ssh credential - smb_credential_id: UUID of a smb credential to use on target - snmp_credential_id: UUID of a snmp credential to use on target - esxi_credential_id: UUID of a esxi credential to use on target - alive_test: Which alive test to use - allow_simultaneous_ips: Whether to scan multiple IPs of the - same host simultaneously - reverse_lookup_only: Whether to scan only hosts that have names - reverse_lookup_unify: Whether to scan only one IP when multiple IPs - have the same name. - port_range: Port range for the target - port_list_id: UUID of the port list to use on target - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_target.__name__, argument="name" - ) - - cmd = XmlCommand("create_target") - cmd.add_element("name", name) - - if asset_hosts_filter: - cmd.add_element( - "asset_hosts", attrs={"filter": str(asset_hosts_filter)} - ) - elif hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - else: - raise RequiredArgument( - function=self.create_target.__name__, - argument="hosts or asset_hosts_filter", - ) - - if comment: - cmd.add_element("comment", comment) - - if exclude_hosts: - cmd.add_element("exclude_hosts", to_comma_list(exclude_hosts)) - - if ssh_credential_id: - _xmlssh = cmd.add_element( - "ssh_credential", attrs={"id": ssh_credential_id} - ) - if ssh_credential_port: - _xmlssh.add_element("port", str(ssh_credential_port)) - - if smb_credential_id: - cmd.add_element("smb_credential", attrs={"id": smb_credential_id}) - - if esxi_credential_id: - cmd.add_element("esxi_credential", attrs={"id": esxi_credential_id}) - - if snmp_credential_id: - cmd.add_element("snmp_credential", attrs={"id": snmp_credential_id}) - - if alive_test: - if not isinstance(alive_test, AliveTest): - raise InvalidArgumentType( - function=self.create_target.__name__, - argument="alive_test", - arg_type=AliveTest.__name__, - ) - - cmd.add_element("alive_tests", alive_test.value) - - if allow_simultaneous_ips is not None: - cmd.add_element( - "allow_simultaneous_ips", to_bool(allow_simultaneous_ips) - ) - - if reverse_lookup_only is not None: - cmd.add_element("reverse_lookup_only", to_bool(reverse_lookup_only)) - - if reverse_lookup_unify is not None: - cmd.add_element( - "reverse_lookup_unify", to_bool(reverse_lookup_unify) - ) - - if port_range: - cmd.add_element("port_range", port_range) - - if port_list_id: - cmd.add_element("port_list", attrs={"id": port_list_id}) - - return self._send_xml_command(cmd) - - def modify_target( - self, - target_id: str, - *, - name: Optional[str] = None, - comment: Optional[str] = None, - hosts: Optional[List[str]] = None, - exclude_hosts: Optional[List[str]] = None, - ssh_credential_id: Optional[str] = None, - ssh_credential_port: Optional[bool] = None, - smb_credential_id: Optional[str] = None, - esxi_credential_id: Optional[str] = None, - snmp_credential_id: Optional[str] = None, - alive_test: Optional[AliveTest] = None, - allow_simultaneous_ips: Optional[bool] = None, - reverse_lookup_only: Optional[bool] = None, - reverse_lookup_unify: Optional[bool] = None, - port_list_id: Optional[str] = None, - ) -> Any: - """Modifies an existing target. - - Arguments: - target_id: ID of target to modify. - comment: Comment on target. - name: Name of target. - hosts: List of target hosts. - exclude_hosts: A list of hosts to exclude. - ssh_credential_id: UUID of SSH credential to use on target. - ssh_credential_port: The port to use for ssh credential - smb_credential_id: UUID of SMB credential to use on target. - esxi_credential_id: UUID of ESXi credential to use on target. - snmp_credential_id: UUID of SNMP credential to use on target. - port_list_id: UUID of port list describing ports to scan. - alive_test: Which alive tests to use. - allow_simultaneous_ips: Whether to scan multiple IPs of the - same host simultaneously - reverse_lookup_only: Whether to scan only hosts that have names. - reverse_lookup_unify: Whether to scan only one IP when multiple IPs - have the same name. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not target_id: - raise RequiredArgument( - function=self.modify_target.__name__, argument="target_id" - ) - - cmd = XmlCommand("modify_target") - cmd.set_attribute("target_id", target_id) - - if comment: - cmd.add_element("comment", comment) - - if name: - cmd.add_element("name", name) - - if hosts: - cmd.add_element("hosts", to_comma_list(hosts)) - if exclude_hosts is None: - exclude_hosts = [""] - - if exclude_hosts: - cmd.add_element("exclude_hosts", to_comma_list(exclude_hosts)) - - if alive_test: - if not isinstance(alive_test, AliveTest): - raise InvalidArgumentType( - function=self.modify_target.__name__, - argument="alive_test", - arg_type=AliveTest.__name__, - ) - cmd.add_element("alive_tests", alive_test.value) - - if ssh_credential_id: - _xmlssh = cmd.add_element( - "ssh_credential", attrs={"id": ssh_credential_id} - ) - - if ssh_credential_port: - _xmlssh.add_element("port", str(ssh_credential_port)) - - if smb_credential_id: - cmd.add_element("smb_credential", attrs={"id": smb_credential_id}) - - if esxi_credential_id: - cmd.add_element("esxi_credential", attrs={"id": esxi_credential_id}) - - if snmp_credential_id: - cmd.add_element("snmp_credential", attrs={"id": snmp_credential_id}) - - if allow_simultaneous_ips is not None: - cmd.add_element( - "allow_simultaneous_ips", to_bool(allow_simultaneous_ips) - ) - - if reverse_lookup_only is not None: - cmd.add_element("reverse_lookup_only", to_bool(reverse_lookup_only)) - - if reverse_lookup_unify is not None: - cmd.add_element( - "reverse_lookup_unify", to_bool(reverse_lookup_unify) - ) - - if port_list_id: - cmd.add_element("port_list", attrs={"id": port_list_id}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv214/entities/users.py b/gvm/protocols/gmpv214/entities/users.py deleted file mode 100644 index 31a2264a6..000000000 --- a/gvm/protocols/gmpv214/entities/users.py +++ /dev/null @@ -1,110 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=arguments-differ, arguments-renamed - -from typing import Any, List, Optional - -from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.users import UserAuthType -from gvm.protocols.gmpv208.entities.users import UsersMixin as Gmp208UsersMixin -from gvm.utils import to_bool, to_comma_list -from gvm.xml import XmlCommand - - -class UsersMixin(Gmp208UsersMixin): - def modify_user( - self, - user_id: str = None, - *, - name: Optional[str] = None, - comment: Optional[str] = None, - password: Optional[str] = None, - auth_source: Optional[UserAuthType] = None, - role_ids: Optional[List[str]] = None, - hosts: Optional[List[str]] = None, - hosts_allow: Optional[bool] = False, - ifaces: Optional[List[str]] = None, - ifaces_allow: Optional[bool] = False, - group_ids: Optional[List[str]] = None, - ) -> Any: - """Modifies an existing user. - - Most of the fields need to be supplied - for changing a single field even if no change is wanted for those. - Else empty values are inserted for the missing fields instead. - - Arguments: - user_id: UUID of the user to be modified. - name: The new name for the user. - comment: Comment on the user. - password: The password for the user. - auth_source: Source allowed for authentication for this user. - roles_id: List of roles UUIDs for the user. - hosts: User access rules: List of hosts. - hosts_allow: Defines how the hosts list is to be interpreted. - If False (default) the list is treated as a deny list. - All hosts are allowed by default except those provided by - the hosts parameter. If True the list is treated as a - allow list. All hosts are denied by default except those - provided by the hosts parameter. - ifaces: User access rules: List of ifaces. - ifaces_allow: Defines how the ifaces list is to be interpreted. - If False (default) the list is treated as a deny list. - All ifaces are allowed by default except those provided by - the ifaces parameter. If True the list is treated as a - allow list. All ifaces are denied by default except those - provided by the ifaces parameter. - group_ids: List of group UUIDs for the user. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not user_id: - raise RequiredArgument( - function=self.modify_user.__name__, argument="user_id" - ) - - cmd = XmlCommand("modify_user") - - cmd.set_attribute("user_id", user_id) - - if name: - cmd.add_element("new_name", name) - - if role_ids: - for role in role_ids: - cmd.add_element("role", attrs={"id": role}) - - if hosts: - cmd.add_element( - "hosts", - to_comma_list(hosts), - attrs={"allow": to_bool(hosts_allow)}, - ) - - if ifaces: - cmd.add_element( - "ifaces", - to_comma_list(ifaces), - attrs={"allow": to_bool(ifaces_allow)}, - ) - - if comment: - cmd.add_element("comment", comment) - - if password: - cmd.add_element("password", password) - - if auth_source: - _xmlauthsrc = cmd.add_element("sources") - _xmlauthsrc.add_element("source", auth_source.value) - - if group_ids: - _xmlgroups = cmd.add_element("groups") - for group_id in group_ids: - _xmlgroups.add_element("group", attrs={"id": group_id}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv214/system/__init__.py b/gvm/protocols/gmpv214/system/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv214/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv214/system/version.py b/gvm/protocols/gmpv214/system/version.py deleted file mode 100644 index c78b4be64..000000000 --- a/gvm/protocols/gmpv214/system/version.py +++ /dev/null @@ -1,23 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -from gvm.protocols.gmpv208.system.version import ( - VersionMixin as Gmp208VersionMixin, -) - -PROTOCOL_VERSION = (21, 4) - - -class VersionMixin(Gmp208VersionMixin): - @staticmethod - def get_protocol_version() -> tuple: - """Determine the Greenbone Management Protocol (gmp) version used - by python-gvm version. - - Returns: - tuple: Implemented version of the Greenbone Management Protocol - """ - return PROTOCOL_VERSION diff --git a/gvm/protocols/gmpv224/__init__.py b/gvm/protocols/gmpv224/__init__.py deleted file mode 100644 index 9e269a92d..000000000 --- a/gvm/protocols/gmpv224/__init__.py +++ /dev/null @@ -1,189 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=too-many-lines,redefined-builtin - -""" -Module for communication with gvmd in -`Greenbone Management Protocol version 22.04`_ - -.. _Greenbone Management Protocol version 22.04: - https://docs.greenbone.net/API/GMP/gmp-22.04.html -""" - -import logging -from typing import Any, Callable, Optional - -from gvm.connections import GvmConnection -from gvm.protocols.base import GvmProtocol -from gvm.protocols.gmpv208.entities.alerts import ( - AlertCondition, - AlertEvent, - AlertMethod, - AlertsMixin, -) -from gvm.protocols.gmpv208.entities.audits import AuditsMixin -from gvm.protocols.gmpv208.entities.credentials import ( - CredentialFormat, - CredentialsMixin, - CredentialType, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, -) -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.protocols.gmpv208.entities.filter import FiltersMixin, FilterType -from gvm.protocols.gmpv208.entities.groups import GroupsMixin -from gvm.protocols.gmpv208.entities.hosts import HostsMixin, HostsOrdering -from gvm.protocols.gmpv208.entities.operating_systems import ( - OperatingSystemsMixin, -) -from gvm.protocols.gmpv208.entities.permissions import ( - PermissionsMixin, - PermissionSubjectType, -) -from gvm.protocols.gmpv208.entities.policies import PoliciesMixin -from gvm.protocols.gmpv208.entities.port_lists import ( - PortListMixin, - PortRangeType, -) -from gvm.protocols.gmpv208.entities.report_formats import ( - ReportFormatsMixin, - ReportFormatType, -) -from gvm.protocols.gmpv208.entities.reports import ReportsMixin -from gvm.protocols.gmpv208.entities.results import ResultsMixin -from gvm.protocols.gmpv208.entities.roles import RolesMixin -from gvm.protocols.gmpv208.entities.schedules import SchedulesMixin -from gvm.protocols.gmpv208.entities.secinfo import InfoType, SecInfoMixin -from gvm.protocols.gmpv208.entities.severity import SeverityLevel -from gvm.protocols.gmpv208.entities.tags import TagsMixin -from gvm.protocols.gmpv208.entities.tasks import TasksMixin -from gvm.protocols.gmpv208.entities.tickets import TicketsMixin, TicketStatus -from gvm.protocols.gmpv208.entities.tls_certificates import TLSCertificateMixin -from gvm.protocols.gmpv208.entities.users import UserAuthType -from gvm.protocols.gmpv208.entities.vulnerabilities import VulnerabilitiesMixin -from gvm.protocols.gmpv208.system.aggregates import ( - AggregatesMixin, - AggregateStatistic, - SortOrder, -) -from gvm.protocols.gmpv208.system.authentication import AuthenticationMixin -from gvm.protocols.gmpv208.system.feed import FeedMixin, FeedType -from gvm.protocols.gmpv208.system.help import HelpFormat, HelpMixin -from gvm.protocols.gmpv208.system.system_reports import SystemReportsMixin -from gvm.protocols.gmpv208.system.trashcan import TrashcanMixin -from gvm.protocols.gmpv208.system.user_settings import UserSettingsMixin - -# NEW IN 214 -from gvm.protocols.gmpv214.entities.notes import NotesMixin -from gvm.protocols.gmpv214.entities.overrides import OverridesMixin -from gvm.protocols.gmpv214.entities.targets import AliveTest, TargetsMixin -from gvm.protocols.gmpv224.entities.scan_configs import ScanConfigsMixin -from gvm.protocols.gmpv224.entities.scanners import ScannersMixin, ScannerType - -# NEW IN 224 -from gvm.protocols.gmpv224.entities.users import UsersMixin -from gvm.protocols.gmpv224.system.version import VersionMixin -from gvm.utils import to_dotted_types_dict - -logger = logging.getLogger(__name__) - -_TYPE_FIELDS = [ - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - HostsOrdering, - InfoType, - HelpFormat, - PortRangeType, - PermissionSubjectType, - ReportFormatType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, -] - - -class Gmp( - GvmProtocol, - AggregatesMixin, - AlertsMixin, - AuditsMixin, - AuthenticationMixin, - CredentialsMixin, - FeedMixin, - FiltersMixin, - GroupsMixin, - HelpMixin, - HostsMixin, - NotesMixin, - OperatingSystemsMixin, - OverridesMixin, - PermissionsMixin, - PoliciesMixin, - PortListMixin, - ReportFormatsMixin, - ReportsMixin, - ResultsMixin, - RolesMixin, - TagsMixin, - TargetsMixin, - TasksMixin, - TicketsMixin, - TLSCertificateMixin, - TrashcanMixin, - ScanConfigsMixin, - ScannersMixin, - SchedulesMixin, - SecInfoMixin, - SystemReportsMixin, - UserSettingsMixin, - UsersMixin, - VersionMixin, - VulnerabilitiesMixin, -): - """Python interface for Greenbone Management Protocol - - This class implements the `Greenbone Management Protocol version 22.04`_ - - Arguments: - connection: Connection to use to talk with the gvmd daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - - .. _Greenbone Management Protocol version 22.04: - https://docs.greenbone.net/API/GMP/gmp-22.04.html - .. _callable: - https://docs.python.org/3/library/functions.html#callable - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - self.types = to_dotted_types_dict(_TYPE_FIELDS) - - super().__init__(connection, transform=transform) - - # Is authenticated on gvmd - self._authenticated = False diff --git a/gvm/protocols/gmpv224/entities/__init__.py b/gvm/protocols/gmpv224/entities/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv224/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv224/entities/scanners.py b/gvm/protocols/gmpv224/entities/scanners.py deleted file mode 100644 index 2b290c6df..000000000 --- a/gvm/protocols/gmpv224/entities/scanners.py +++ /dev/null @@ -1,201 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -from enum import Enum -from typing import Any, Optional - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.scanners import ( - ScannersMixin as Gmp208ScannersMixin, -) -from gvm.xml import XmlCommand - - -class ScannerType(Enum): - """Enum for scanner type""" - - # 1 was removed (OSP_SCANNER_TYPE). - OPENVAS_SCANNER_TYPE = "2" - CVE_SCANNER_TYPE = "3" - GREENBONE_SENSOR_SCANNER_TYPE = "5" - - @classmethod - def from_string( - cls, - scanner_type: Optional[str], - ) -> Optional["ScannerType"]: - """Convert a scanner type string to an actual ScannerType instance - - Arguments: - scanner_type: Scanner type string to convert to a ScannerType - """ - if not scanner_type: - return None - - scanner_type = scanner_type.lower() - - if ( - scanner_type == cls.OPENVAS_SCANNER_TYPE.value - or scanner_type == "openvas" - ): - return cls.OPENVAS_SCANNER_TYPE - - if scanner_type == cls.CVE_SCANNER_TYPE.value or scanner_type == "cve": - return cls.CVE_SCANNER_TYPE - - if ( - scanner_type == cls.GREENBONE_SENSOR_SCANNER_TYPE.value - or scanner_type == "greenbone" - ): - return cls.GREENBONE_SENSOR_SCANNER_TYPE - - raise InvalidArgument( - argument="scanner_type", function=cls.from_string.__name__ - ) - - -class ScannersMixin(Gmp208ScannersMixin): - # Override bc. of ScannerType (?) - - def create_scanner( - self, - name: str, - host: str, - port: int, - scanner_type: ScannerType, - credential_id: str, - *, - ca_pub: Optional[str] = None, - comment: Optional[str] = None, - ) -> Any: - """Create a new scanner - - Arguments: - name: Name of the scanner - host: The host of the scanner - port: The port of the scanner - scanner_type: Type of the scanner. - credential_id: UUID of client certificate credential for the - scanner - ca_pub: Certificate of CA to verify scanner certificate - comment: Comment for the scanner - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="name" - ) - - if not host: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="host" - ) - - if not port: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="port" - ) - - if not scanner_type: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="scanner_type" - ) - - if not credential_id: - raise RequiredArgument( - function=self.create_scanner.__name__, argument="credential_id" - ) - - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.create_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, - ) - - cmd = XmlCommand("create_scanner") - cmd.add_element("name", name) - cmd.add_element("host", host) - cmd.add_element("port", str(port)) - cmd.add_element("type", scanner_type.value) - - if ca_pub: - cmd.add_element("ca_pub", ca_pub) - - cmd.add_element("credential", attrs={"id": str(credential_id)}) - - if comment: - cmd.add_element("comment", comment) - - return self._send_xml_command(cmd) - - def modify_scanner( - self, - scanner_id: str, - *, - scanner_type: Optional[ScannerType] = None, - host: Optional[str] = None, - port: Optional[int] = None, - comment: Optional[str] = None, - name: Optional[str] = None, - ca_pub: Optional[str] = None, - credential_id: Optional[str] = None, - ) -> Any: - """Modifies an existing scanner. - - Arguments: - scanner_id: UUID of scanner to modify. - scanner_type: New type of the Scanner. - host: Host of the scanner. - port: Port of the scanner. - comment: Comment on scanner. - name: Name of scanner. - ca_pub: Certificate of CA to verify scanner's certificate. - credential_id: UUID of the client certificate credential for the - Scanner. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not scanner_id: - raise RequiredArgument( - function=self.modify_scanner.__name__, - argument="scanner_id argument", - ) - - cmd = XmlCommand("modify_scanner") - cmd.set_attribute("scanner_id", scanner_id) - - if scanner_type is not None: - if not isinstance(scanner_type, ScannerType): - raise InvalidArgumentType( - function=self.modify_scanner.__name__, - argument="scanner_type", - arg_type=ScannerType.__name__, - ) - - cmd.add_element("type", scanner_type.value) - - if host: - cmd.add_element("host", host) - - if port: - cmd.add_element("port", str(port)) - - if comment: - cmd.add_element("comment", comment) - - if name: - cmd.add_element("name", name) - - if ca_pub: - cmd.add_element("ca_pub", ca_pub) - - if credential_id: - cmd.add_element("credential", attrs={"id": str(credential_id)}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv224/entities/users.py b/gvm/protocols/gmpv224/entities/users.py deleted file mode 100644 index 39333bf3a..000000000 --- a/gvm/protocols/gmpv224/entities/users.py +++ /dev/null @@ -1,176 +0,0 @@ -# SPDX-FileCopyrightText: 2022-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=arguments-differ, arguments-renamed - -from typing import Any, List, Optional - -from gvm.errors import RequiredArgument -from gvm.protocols.gmpv214.entities.users import UserAuthType -from gvm.protocols.gmpv214.entities.users import UsersMixin as Gmp214UsersMixin -from gvm.utils import deprecation, to_bool, to_comma_list -from gvm.xml import XmlCommand - - -class UsersMixin(Gmp214UsersMixin): - def create_user( - self, - name: str, - *, - password: Optional[str] = None, - hosts: Optional[List[str]] = None, - hosts_allow: Optional[bool] = False, - ifaces: Any = None, - ifaces_allow: Any = None, - role_ids: Optional[List[str]] = None, - ) -> Any: - """Create a new user - - Arguments: - name: Name of the user - password: Password of the user - hosts: A list of host addresses (IPs, DNS names) - hosts_allow: If True allow only access to passed hosts otherwise - deny access. Default is False for deny hosts. - ifaces: deprecated - ifaces_allow: deprecated - role_ids: A list of role UUIDs for the user - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not name: - raise RequiredArgument( - function=self.create_user.__name__, argument="name" - ) - - cmd = XmlCommand("create_user") - cmd.add_element("name", name) - - if password: - cmd.add_element("password", password) - - if hosts: - cmd.add_element( - "hosts", - to_comma_list(hosts), - attrs={"allow": to_bool(hosts_allow)}, - ) - - if ifaces is not None: - major, minor = self.get_protocol_version() - deprecation( - "The ifaces parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if ifaces_allow is not None: - major, minor = self.get_protocol_version() - deprecation( - "The ifaces_allow parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if role_ids: - for role in role_ids: - cmd.add_element("role", attrs={"id": role}) - - return self._send_xml_command(cmd) - - def modify_user( - self, - user_id: str = None, - *, - name: Optional[str] = None, - comment: Optional[str] = None, - password: Optional[str] = None, - auth_source: Optional[UserAuthType] = None, - role_ids: Optional[List[str]] = None, - hosts: Optional[List[str]] = None, - hosts_allow: Optional[bool] = False, - ifaces: Any = None, - ifaces_allow: Any = None, - group_ids: Optional[List[str]] = None, - ) -> Any: - """Modifies an existing user. - - Most of the fields need to be supplied - for changing a single field even if no change is wanted for those. - Else empty values are inserted for the missing fields instead. - - Arguments: - user_id: UUID of the user to be modified. - name: The new name for the user. - comment: Comment on the user. - password: The password for the user. - auth_source: Source allowed for authentication for this user. - roles_id: List of roles UUIDs for the user. - hosts: User access rules: List of hosts. - hosts_allow: Defines how the hosts list is to be interpreted. - If False (default) the list is treated as a deny list. - All hosts are allowed by default except those provided by - the hosts parameter. If True the list is treated as a - allow list. All hosts are denied by default except those - provided by the hosts parameter. - ifaces: deprecated - ifaces_allow: deprecated - group_ids: List of group UUIDs for the user. - - Returns: - The response. See :py:meth:`send_command` for details. - """ - if not user_id: - raise RequiredArgument( - function=self.modify_user.__name__, argument="user_id" - ) - - cmd = XmlCommand("modify_user") - - cmd.set_attribute("user_id", user_id) - - if name: - cmd.add_element("new_name", name) - - if role_ids: - for role in role_ids: - cmd.add_element("role", attrs={"id": role}) - - if hosts: - cmd.add_element( - "hosts", - to_comma_list(hosts), - attrs={"allow": to_bool(hosts_allow)}, - ) - - if ifaces is not None: - major, minor = self.get_protocol_version() - deprecation( - "The ifaces parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if ifaces_allow is not None: - major, minor = self.get_protocol_version() - deprecation( - "The ifaces_allow parameter has been removed in GMP" - f" version {major}{minor}" - ) - - if comment: - cmd.add_element("comment", comment) - - if password: - cmd.add_element("password", password) - - if auth_source: - _xmlauthsrc = cmd.add_element("sources") - _xmlauthsrc.add_element("source", auth_source.value) - - if group_ids: - _xmlgroups = cmd.add_element("groups") - for group_id in group_ids: - _xmlgroups.add_element("group", attrs={"id": group_id}) - - return self._send_xml_command(cmd) diff --git a/gvm/protocols/gmpv224/system/__init__.py b/gvm/protocols/gmpv224/system/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/gvm/protocols/gmpv224/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv224/system/version.py b/gvm/protocols/gmpv224/system/version.py deleted file mode 100644 index c16c766b5..000000000 --- a/gvm/protocols/gmpv224/system/version.py +++ /dev/null @@ -1,23 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -from gvm.protocols.gmpv208.system.version import ( - VersionMixin as Gmp208VersionMixin, -) - -PROTOCOL_VERSION = (22, 4) - - -class VersionMixin(Gmp208VersionMixin): - @staticmethod - def get_protocol_version() -> tuple: - """Determine the Greenbone Management Protocol (gmp) version used - by python-gvm version. - - Returns: - tuple: Implemented version of the Greenbone Management Protocol - """ - return PROTOCOL_VERSION diff --git a/gvm/protocols/gmpv225/__init__.py b/gvm/protocols/gmpv225/__init__.py deleted file mode 100644 index 7a74fa42b..000000000 --- a/gvm/protocols/gmpv225/__init__.py +++ /dev/null @@ -1,197 +0,0 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -# pylint: disable=too-many-lines,redefined-builtin - -""" -Module for communication with gvmd in -`Greenbone Management Protocol version 22.05`_ - -.. _Greenbone Management Protocol version 22.05: - https://docs.greenbone.net/API/GMP/gmp-22.05.html -""" - -import logging -from typing import Any, Callable, Optional - -from gvm.connections import GvmConnection -from gvm.protocols.base import GvmProtocol -from gvm.protocols.gmpv208.entities.alerts import ( - AlertCondition, - AlertEvent, - AlertMethod, - AlertsMixin, -) -from gvm.protocols.gmpv208.entities.audits import AuditsMixin -from gvm.protocols.gmpv208.entities.credentials import ( - CredentialFormat, - CredentialsMixin, - CredentialType, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, -) -from gvm.protocols.gmpv208.entities.entities import EntityType -from gvm.protocols.gmpv208.entities.filter import FiltersMixin, FilterType -from gvm.protocols.gmpv208.entities.groups import GroupsMixin -from gvm.protocols.gmpv208.entities.hosts import HostsMixin, HostsOrdering -from gvm.protocols.gmpv208.entities.operating_systems import ( - OperatingSystemsMixin, -) -from gvm.protocols.gmpv208.entities.permissions import ( - PermissionsMixin, - PermissionSubjectType, -) -from gvm.protocols.gmpv208.entities.policies import PoliciesMixin -from gvm.protocols.gmpv208.entities.port_lists import ( - PortListMixin, - PortRangeType, -) -from gvm.protocols.gmpv208.entities.report_formats import ( - ReportFormatsMixin, - ReportFormatType, -) -from gvm.protocols.gmpv208.entities.reports import ReportsMixin -from gvm.protocols.gmpv208.entities.results import ResultsMixin -from gvm.protocols.gmpv208.entities.roles import RolesMixin -from gvm.protocols.gmpv208.entities.schedules import SchedulesMixin -from gvm.protocols.gmpv208.entities.secinfo import InfoType, SecInfoMixin -from gvm.protocols.gmpv208.entities.severity import SeverityLevel -from gvm.protocols.gmpv208.entities.tags import TagsMixin -from gvm.protocols.gmpv208.entities.tasks import TasksMixin -from gvm.protocols.gmpv208.entities.tickets import TicketsMixin, TicketStatus -from gvm.protocols.gmpv208.entities.tls_certificates import TLSCertificateMixin -from gvm.protocols.gmpv208.entities.users import UserAuthType -from gvm.protocols.gmpv208.entities.vulnerabilities import VulnerabilitiesMixin -from gvm.protocols.gmpv208.system.aggregates import ( - AggregatesMixin, - AggregateStatistic, - SortOrder, -) -from gvm.protocols.gmpv208.system.authentication import AuthenticationMixin -from gvm.protocols.gmpv208.system.feed import FeedMixin, FeedType -from gvm.protocols.gmpv208.system.help import HelpFormat, HelpMixin -from gvm.protocols.gmpv208.system.system_reports import SystemReportsMixin -from gvm.protocols.gmpv208.system.trashcan import TrashcanMixin -from gvm.protocols.gmpv208.system.user_settings import UserSettingsMixin - -# NEW IN 214 -from gvm.protocols.gmpv214.entities.notes import NotesMixin -from gvm.protocols.gmpv214.entities.overrides import OverridesMixin -from gvm.protocols.gmpv214.entities.targets import AliveTest, TargetsMixin -from gvm.protocols.gmpv224.entities.scan_configs import ScanConfigsMixin -from gvm.protocols.gmpv224.entities.scanners import ScannersMixin, ScannerType - -# NEW IN 224 -from gvm.protocols.gmpv224.entities.users import UsersMixin - -# NEW IN 225 -from gvm.protocols.gmpv225.entities.resourcenames import ( - ResourceNamesMixin, - ResourceType, -) -from gvm.protocols.gmpv225.system.version import VersionMixin -from gvm.utils import to_dotted_types_dict - -logger = logging.getLogger(__name__) - -_TYPE_FIELDS = [ - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - HostsOrdering, - InfoType, - HelpFormat, - PortRangeType, - PermissionSubjectType, - ReportFormatType, - ResourceType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, -] - - -class Gmp( - GvmProtocol, - AggregatesMixin, - AlertsMixin, - AuditsMixin, - AuthenticationMixin, - CredentialsMixin, - FeedMixin, - FiltersMixin, - GroupsMixin, - HelpMixin, - HostsMixin, - NotesMixin, - OperatingSystemsMixin, - OverridesMixin, - PermissionsMixin, - PoliciesMixin, - PortListMixin, - ReportFormatsMixin, - ReportsMixin, - ResourceNamesMixin, - ResultsMixin, - RolesMixin, - TagsMixin, - TargetsMixin, - TasksMixin, - TicketsMixin, - TLSCertificateMixin, - TrashcanMixin, - ScanConfigsMixin, - ScannersMixin, - SchedulesMixin, - SecInfoMixin, - SystemReportsMixin, - UserSettingsMixin, - UsersMixin, - VersionMixin, - VulnerabilitiesMixin, -): - """Python interface for Greenbone Management Protocol - - This class implements the `Greenbone Management Protocol version 22.05`_ - - Arguments: - connection: Connection to use to talk with the gvmd daemon. See - :mod:`gvm.connections` for possible connection types. - transform: Optional transform `callable`_ to convert response data. - After each request the callable gets passed the plain response data - which can be used to check the data and/or conversion into different - representations like a xml dom. - - See :mod:`gvm.transforms` for existing transforms. - - .. _Greenbone Management Protocol version 22.05: - https://docs.greenbone.net/API/GMP/gmp-22.05.html - .. _callable: - https://docs.python.org/3/library/functions.html#callable - """ - - def __init__( - self, - connection: GvmConnection, - *, - transform: Optional[Callable[[str], Any]] = None, - ): - self.types = to_dotted_types_dict(_TYPE_FIELDS) - - super().__init__(connection, transform=transform) - - # Is authenticated on gvmd - self._authenticated = False diff --git a/gvm/protocols/gmpv225/entities/__init__.py b/gvm/protocols/gmpv225/entities/__init__.py deleted file mode 100644 index baae7654d..000000000 --- a/gvm/protocols/gmpv225/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv225/system/__init__.py b/gvm/protocols/gmpv225/system/__init__.py deleted file mode 100644 index baae7654d..000000000 --- a/gvm/protocols/gmpv225/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/gvm/protocols/gmpv225/system/version.py b/gvm/protocols/gmpv225/system/version.py deleted file mode 100644 index e879c29fd..000000000 --- a/gvm/protocols/gmpv225/system/version.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.protocols.gmpv208.system.version import ( - VersionMixin as Gmp208VersionMixin, -) - -PROTOCOL_VERSION = (22, 5) - - -class VersionMixin(Gmp208VersionMixin): - @staticmethod - def get_protocol_version() -> tuple: - """Determine the Greenbone Management Protocol (gmp) version used - by python-gvm version. - - Returns: - tuple: Implemented version of the Greenbone Management Protocol - """ - return PROTOCOL_VERSION diff --git a/gvm/protocols/latest.py b/gvm/protocols/latest.py index 35ab346aa..adeab6553 100644 --- a/gvm/protocols/latest.py +++ b/gvm/protocols/latest.py @@ -14,67 +14,19 @@ :py:mod:`gvm.protocols`. Exports: - - :py:class:`gvm.protocols.gmpv225.Gmp` + - :py:class:`gvm.protocols.gmp.GMPv224` - :py:class:`gvm.protocols.ospv1.Osp` .. _Greenbone Management Protocol: https://docs.greenbone.net/API/GMP/gmp.html """ -from .gmpv225 import ( - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - Gmp, - HelpFormat, - HostsOrdering, - InfoType, - PermissionSubjectType, - PortRangeType, - ReportFormatType, - ResourceType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, +from .gmp import ( + GMPv225 as Gmp, ) from .ospv1 import Osp __all__ = [ "Gmp", "Osp", - "AggregateStatistic", - "AlertCondition", - "AlertEvent", - "AlertMethod", - "AliveTest", - "CredentialType", - "CredentialFormat", - "EntityType", - "FeedType", - "FilterType", - "HelpFormat", - "HostsOrdering", - "InfoType", - "PermissionSubjectType", - "PortRangeType", - "ReportFormatType", - "ResourceType", - "ScannerType", - "SeverityLevel", - "SnmpAuthAlgorithm", - "SnmpPrivacyAlgorithm", - "SortOrder", - "TicketStatus", - "UserAuthType", ] diff --git a/gvm/protocols/next.py b/gvm/protocols/next.py index 35ab346aa..cc2d58e8f 100644 --- a/gvm/protocols/next.py +++ b/gvm/protocols/next.py @@ -14,67 +14,19 @@ :py:mod:`gvm.protocols`. Exports: - - :py:class:`gvm.protocols.gmpv225.Gmp` + - :py:class:`gvm.protocols.gmp.GMPv225` - :py:class:`gvm.protocols.ospv1.Osp` .. _Greenbone Management Protocol: https://docs.greenbone.net/API/GMP/gmp.html """ -from .gmpv225 import ( - AggregateStatistic, - AlertCondition, - AlertEvent, - AlertMethod, - AliveTest, - CredentialFormat, - CredentialType, - EntityType, - FeedType, - FilterType, - Gmp, - HelpFormat, - HostsOrdering, - InfoType, - PermissionSubjectType, - PortRangeType, - ReportFormatType, - ResourceType, - ScannerType, - SeverityLevel, - SnmpAuthAlgorithm, - SnmpPrivacyAlgorithm, - SortOrder, - TicketStatus, - UserAuthType, +from .gmp import ( + GMPv225 as Gmp, ) from .ospv1 import Osp __all__ = [ "Gmp", "Osp", - "AggregateStatistic", - "AlertCondition", - "AlertEvent", - "AlertMethod", - "AliveTest", - "CredentialType", - "CredentialFormat", - "EntityType", - "FeedType", - "FilterType", - "HelpFormat", - "HostsOrdering", - "InfoType", - "PermissionSubjectType", - "PortRangeType", - "ReportFormatType", - "ResourceType", - "ScannerType", - "SeverityLevel", - "SnmpAuthAlgorithm", - "SnmpPrivacyAlgorithm", - "SortOrder", - "TicketStatus", - "UserAuthType", ] diff --git a/gvm/protocols/ospv1.py b/gvm/protocols/ospv1.py index 77033b17a..ae4e190a9 100644 --- a/gvm/protocols/ospv1.py +++ b/gvm/protocols/ospv1.py @@ -9,59 +9,68 @@ https://docs.greenbone.net/API/OSP/osp-20.08.html """ import logging +from typing import Any, Optional from gvm.errors import InvalidArgument, RequiredArgument -from gvm.xml import XmlCommand +from gvm.utils import to_bool +from gvm.xml import XmlCommand, XmlCommandElement -from .base import GvmProtocol +from ._protocol import GvmProtocol, T +from .core import Request, Response logger = logging.getLogger(__name__) PROTOCOL_VERSION = (1, 2) -def create_credentials_element(_xmlcredentials, credentials): +def create_credentials_element( + xml_credentials: XmlCommandElement, credentials: dict[str, dict[str, str]] +): """Generates an xml element with credentials.""" for service, credential in credentials.items(): - cred_type = credential.get("type") - serv_port = credential.get("port") + cred_type = credential.get("type", "") + server_port = credential.get("port", "") username = credential.get("username") password = credential.get("password") - _xmlcredential = _xmlcredentials.add_element("credential") - _xmlcredential.set_attribute("type", cred_type) - _xmlcredential.set_attribute("port", serv_port) - _xmlcredential.set_attribute("service", service) + xml_credential = xml_credentials.add_element("credential") + xml_credential.set_attribute("type", cred_type) + xml_credential.set_attribute("port", server_port) + xml_credential.set_attribute("service", service) - _xmlcredential.add_element("username", username) - _xmlcredential.add_element("password", password) - return _xmlcredentials + xml_credential.add_element("username", username) + xml_credential.add_element("password", password) + return xml_credentials -def create_vt_selection_element(_xmlvtselection, vt_selection): +def create_vt_selection_element( + xml_vt_selection: XmlCommandElement, vt_selection: dict[str, Any] +): """Generates an xml element with a selection of Vulnerability tests.""" for vt_id, vt_values in vt_selection.items(): if vt_id != "vt_groups" and isinstance(vt_values, dict): - _xmlvt = _xmlvtselection.add_element( + xml_vt = xml_vt_selection.add_element( "vt_single", attrs={"id": vt_id} ) if vt_values: for key, value in vt_values.items(): - _xmlvt.add_element("vt_value", value, attrs={"id": key}) + xml_vt.add_element("vt_value", value, attrs={"id": key}) elif vt_id == "vt_groups" and isinstance(vt_values, list): for group in vt_values: - _xmlvtselection.add_element("vt_group", attrs={"filter": group}) + xml_vt_selection.add_element( + "vt_group", attrs={"filter": group} + ) else: raise InvalidArgument( f"It was not possible to add {vt_id} to the VTs selection." ) - return _xmlvtselection + return xml_vt_selection -class Osp(GvmProtocol): +class Osp(GvmProtocol[T]): @staticmethod - def get_protocol_version(): + def get_protocol_version() -> tuple[int, int]: """Determine the Open Scanner Protocol version. Returns: @@ -69,24 +78,30 @@ def get_protocol_version(): """ return PROTOCOL_VERSION - def _read(self): - # OSP is stateless. Therefore the connection is closed after each - # response and we must reset the connection - data = super()._read() - self.disconnect() - return data + def _send_command(self, cmd: Request) -> Response: + try: + return super()._send_command(cmd) + finally: + # OSP is stateless. Therefore the connection is closed after each + # response and we must reset the connection + self.disconnect() - def get_version(self): + def get_version(self) -> T: """Get the version of the OSPD server which is connected to.""" cmd = XmlCommand("get_version") - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def help(self): + def help(self) -> T: """Get the help text.""" cmd = XmlCommand("help") - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def get_scans(self, scan_id=None, details=True, pop_results=False): + def get_scans( + self, + scan_id: Optional[str] = None, + details: bool = True, + pop_results: bool = False, + ) -> T: """Get the stored scans. Arguments: @@ -95,89 +110,69 @@ def get_scans(self, scan_id=None, details=True, pop_results=False): Default: True pop_results (boolean, optional) Whether to remove the fetched results. Default: False - - Returns: - str: Response from server. """ cmd = XmlCommand("get_scans") if scan_id: cmd.set_attribute("scan_id", scan_id) - if details: - cmd.set_attribute("details", "1") - else: - cmd.set_attribute("details", "0") - if pop_results: - cmd.set_attribute("pop_results", "1") - else: - cmd.set_attribute("pop_results", "0") + cmd.set_attribute("details", to_bool(details)) + cmd.set_attribute("pop_results", to_bool(pop_results)) - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def delete_scan(self, scan_id=None): + def delete_scan(self, scan_id: str) -> T: """Delete a finished scan. Arguments: - scan_id (str): UUID identifier for a finished scan. - - Returns: - str: Response from server. + scan_id: UUID identifier for a finished scan. """ if not scan_id: raise ValueError("delete_scan requires a scan_id element") + cmd = XmlCommand("delete_scan") cmd.set_attribute("scan_id", scan_id) - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def get_scanner_details(self): + def get_scanner_details(self) -> T: """Return scanner description and parameters.""" cmd = XmlCommand("get_scanner_details") - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def get_vts(self, vt_id=None): + def get_vts(self, vt_id: Optional[str] = None) -> T: """Return information about vulnerability tests, if offered by scanner. - Arguments: - vt_id (str, optional): UUID identifier for a vulnerability test. - - Returns: - str: Response from server. + Args: + vt_id: UUID identifier for a vulnerability test. """ cmd = XmlCommand("get_vts") if vt_id: cmd.set_attribute("vt_id", vt_id) - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) def start_scan( self, - scan_id=None, - parallel=1, + scan_id: Optional[str] = None, + parallel: int = 1, target=None, ports=None, - targets=None, - scanner_params=None, - vt_selection=None, - ): + targets: Optional[list[dict[str, str]]] = None, + scanner_params: Optional[dict[str, Any]] = None, + vt_selection: Optional[dict[str, Any]] = None, + ) -> T: """Start a new scan. - Arguments: - scan_id (str, optional): UUID identifier for a running scan. - parallel (int, optional): Number of parallel scanned targets. + Args: + scan_id: UUID identifier for a running scan. + parallel: Number of parallel scanned targets. Default 1. - target (dict, optional): Deprecated. Please use targets instead. - targets (list, optional): List of dictionaries. See example. - ports (str, optional): Deprecated. Ports to use for target - parameter. - scanner_params: (dict, optional): Dictionary of scanner parameters. - vt_selection: (dict, optional): Vulnerability tests to select. See - example. - - Returns: - str: Response from server. - + target: Deprecated. Please use targets instead. + targets: List of dictionaries. See example. + ports: Deprecated. Ports to use for target parameter. + scanner_params:: Dictionary of scanner parameters. + vt_selection:: Vulnerability tests to select. See example. Examples: @@ -223,22 +218,22 @@ def start_scan( cmd.set_attribute("parallel", str(parallel)) # Add even if it is empty, since it is mandatory - _xmlscanparams = cmd.add_element("scanner_params") + xml_scan_params = cmd.add_element("scanner_params") if scanner_params: - _xmlscanparams.set_attributes(scanner_params) + xml_scan_params.set_attributes(scanner_params) if targets: - _xmltargets = cmd.add_element("targets") + xml_targets = cmd.add_element("targets") for target in targets: - _xmltarget = _xmltargets.add_element("target") + xml_target = xml_targets.add_element("target") hosts = target.get("hosts") ports = target.get("ports") credentials = target.get("credentials") - _xmltarget.add_element("hosts", hosts) - _xmltarget.add_element("ports", ports) + xml_target.add_element("hosts", hosts) + xml_target.add_element("ports", ports) if credentials: create_credentials_element( - _xmltarget.add_element("credentials"), credentials + xml_target.add_element("credentials"), credentials ) # Check target as attribute for legacy mode compatibility. Deprecated. elif target: @@ -255,16 +250,13 @@ def start_scan( cmd.add_element("vt_selection"), vt_selection ) - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) - def stop_scan(self, scan_id): + def stop_scan(self, scan_id: str) -> T: """Stop a currently running scan. Args: - scan_id (str): UUID identifier for a running scan. - - Returns: - str: Response from server. + scan_id: UUID identifier for a running scan. """ if not scan_id: raise RequiredArgument( @@ -274,4 +266,4 @@ def stop_scan(self, scan_id): cmd = XmlCommand("stop_scan") cmd.set_attribute("scan_id", scan_id) - return self._send_xml_command(cmd) + return self._send_and_transform_command(cmd) diff --git a/gvm/transforms.py b/gvm/transforms.py index bb5a12453..7add892da 100644 --- a/gvm/transforms.py +++ b/gvm/transforms.py @@ -8,7 +8,7 @@ from lxml import etree from .errors import GvmError, GvmResponseError, GvmServerError -from .xml import create_parser +from .xml import Element, create_parser class EtreeTransform: @@ -19,18 +19,18 @@ class EtreeTransform: def __init__(self): self._parser = create_parser() - def _convert_response(self, response: str) -> etree.Element: + def _convert_response(self, response: str) -> Element: return etree.XML(response, parser=self._parser) - def __call__(self, response: str) -> etree.Element: + def __call__(self, response: str) -> Element: return self._convert_response(response) -def check_command_status(root: etree.Element): +def check_command_status(root: Element): status = root.get("status") if status is None: - raise GvmServerError("No status in response.", root) + raise GvmServerError("No status in response.", str(root)) if status[0] == "4": raise GvmResponseError(status=status, message=root.get("status_text")) @@ -46,7 +46,7 @@ class CheckCommandTransform(EtreeTransform): response was an error response """ - def __call__(self, response: str) -> str: + def __call__(self, response: str) -> str: # type: ignore[override] root = self._convert_response(response) check_command_status(root) @@ -60,7 +60,7 @@ class EtreeCheckCommandTransform(EtreeTransform): response was an error response """ - def __call__(self, response: str) -> etree.Element: + def __call__(self, response: str) -> Element: root = self._convert_response(response) check_command_status(root) diff --git a/gvm/utils.py b/gvm/utils.py index 500af42b5..93ce82c0e 100644 --- a/gvm/utils.py +++ b/gvm/utils.py @@ -9,11 +9,19 @@ import logging import re import warnings -from typing import Any, List - -from lxml import etree - -from gvm.xml import create_parser +from functools import wraps +from typing import ( + Any, + Callable, + Iterable, + List, + Optional, + Protocol, + Type, + Union, +) + +from gvm.xml import XmlCommand, XmlError, parse_xml logger = logging.getLogger(__name__) @@ -22,14 +30,87 @@ class TypesDict(dict): """For dot.notation access to dictionary attributes""" __getattr__ = dict.get - __setattr__ = dict.__setitem__ - __delattr__ = dict.__delitem__ + __setattr__ = dict.__setitem__ # type: ignore[assignment] + __delattr__ = dict.__delitem__ # type: ignore[assignment] def deprecation(message: str): warnings.warn(message, DeprecationWarning, stacklevel=2) +def deprecated( + _func_or_cls: Union[str, Callable, Type, None] = None, + *, + since: Optional[str] = None, + reason: Optional[str] = None, +): + """ + A decorator to mark functions, classes and methods as deprecated + + Args: + since: An optional version since the referenced item is deprecated. + reason: An optional reason why the references item is deprecated. + + Examples: + .. code-block:: python + + from gvm.utils import deprecated + + @deprecated + def my_function(*args, **kwargs): + ... + + @deprecated("The function is obsolete. Please use my_func instead.") + def my_function(*args, **kwargs): + ... + + @deprecated( + since="1.2.3", + reason="The function is obsolete. Please use my_func instead." + ) + def my_function(*args, **kwargs): + ... + + @deprecated(reason="The class will be removed in version 3.4.5") + class Foo: + ... + + class Foo: + @deprecated(since="2.3.4") + def bar(self, *args, **kwargs): + ... + """ + if isinstance(_func_or_cls, str): + reason = _func_or_cls + _func_or_cls = None + + def decorator_repeat(func_or_cls): + module = func_or_cls.__module__ + name = func_or_cls.__name__ + + if module == "__main__": + msg = f"{name} is deprecated." + else: + msg = f"{module}.{name} is deprecated." + + if since: + msg += f" It is deprecated since version {since}." + if reason: + msg += f" {reason}" + + @wraps(func_or_cls) + def wrapper(*args, **kwargs): + warnings.warn(msg, category=DeprecationWarning, stacklevel=3) + return func_or_cls(*args, **kwargs) + + return wrapper + + if _func_or_cls is None: + return decorator_repeat + else: + return decorator_repeat(_func_or_cls) + + def check_command_status(xml: str) -> bool: """Check gmp response @@ -47,15 +128,14 @@ def check_command_status(xml: str) -> bool: return False try: - root = etree.XML(xml, parser=create_parser()) + root = parse_xml(xml) status = root.attrib["status"] return status is not None and status[0] == "2" except KeyError: - print(logger) logger.error("Not received an status code within the response.") return False - except etree.Error as e: - logger.error("etree.XML(xml): %s", e) + except XmlError as e: + logger.error("Error while parsing the command status: %s", e) return False @@ -67,24 +147,27 @@ def to_dotted_types_dict(types: List) -> TypesDict: return TypesDict(dic) -def to_bool(value: bool) -> str: +def to_bool(value: Union[bool, int, None]) -> str: return "1" if value else "0" -def to_base64(value: str) -> bytes: - return base64.b64encode(value.encode("utf-8")) +def to_base64(value: str) -> str: + return base64.b64encode(value.encode("utf-8")).decode(encoding="utf-8") + +class SupportsStr(Protocol): + def __str__(self) -> str: ... -def to_comma_list(value: List) -> str: - return ",".join(value) +def to_comma_list(value: Iterable[SupportsStr]) -> str: + return ",".join([str(value) for value in value]) -def add_filter(cmd, filter_string, filter_id): - if filter_string: - cmd.set_attribute("filter", filter_string) - if filter_id: - cmd.set_attribute("filt_id", filter_id) +@deprecated(since="24.3.0", reason="Please use XmlCommand.add_filter instead.") +def add_filter( + cmd: XmlCommand, filter_string: Optional[str], filter_id: Optional[str] +) -> None: + cmd.add_filter(filter_string, filter_id) def is_list_like(value: Any) -> bool: @@ -95,6 +178,4 @@ def check_port(value: str) -> bool: pattern = re.compile( r"^(cpe:[^\s]+|(general|[1-9][0-9]{0,4})/[0-9A-Za-z]+)$" ) - if pattern.fullmatch(value): - return True - return False + return bool(pattern.fullmatch(value)) diff --git a/gvm/xml.py b/gvm/xml.py index 5d4cc7392..b07b418ec 100644 --- a/gvm/xml.py +++ b/gvm/xml.py @@ -5,25 +5,84 @@ import sys from io import IOBase -from typing import List, Optional, Union +from typing import AnyStr, Optional, TextIO, Union +from uuid import UUID -import defusedxml.lxml as secET -from defusedxml import DefusedXmlException -from lxml.etree import Element, LxmlError, SubElement, XMLParser -from lxml.etree import iselement as isxmlelement -from lxml.etree import tostring as xmltostring +from lxml.etree import DocInfo, SubElement, XMLParser +from lxml.etree import Element as create_element +from lxml.etree import Error as EtreeError +from lxml.etree import _Element as Element +from lxml.etree import iselement as is_xml_element +from lxml.etree import tostring as xml_to_string from gvm.errors import GvmError, InvalidArgumentType +__all__ = ( + "Element", + "create_parser", + "parse_xml", + "XmlCommandElement", + "XmlCommand", + "pretty_print", +) + + +class XmlError(GvmError): + pass + + +def check_xml_document( + root_element: Element, + forbid_dtd: bool = False, + forbid_entities: bool = True, +) -> None: + """ + Check an element for DTD and entity declarations + """ + doc_info: DocInfo = root_element.getroottree().docinfo + if doc_info.doctype: # type: ignore + if forbid_dtd: + raise XmlError( + "XML document contains a forbidden DTD declaration " + f"{doc_info.system_url} {doc_info.public_id}" # type: ignore + ) + + if forbid_entities: + for dtd in doc_info.internalDTD, doc_info.externalDTD: + if dtd is None: + continue + for entity in dtd.iterentities(): # type: ignore + raise XmlError( + f"XML Document contains forbidden entity declaration " + f"{entity.name} {entity.content}" + ) + def create_parser(): # huge_tree => disable security restrictions and support very deep trees and # very long text content (for get_reports) - return XMLParser(encoding="utf-8", huge_tree=True) + # resolve_entities=False => disable entity resolution for security reasons + return XMLParser(encoding="utf-8", huge_tree=True, resolve_entities=False) + + +def parse_xml(xml: AnyStr) -> Element: + """ + Parse an XML string and return the root element + + Raises an XmlError if the XML is invalid. + """ + parser = create_parser() + try: + parser.feed(xml) + element = parser.close() + check_xml_document(element) + return element + except EtreeError as e: + raise XmlError(f"Invalid XML {xml!r}. Error was {e}") from e class XmlCommandElement: - def __init__(self, element): + def __init__(self, element: Element): self._element = element def add_element( @@ -32,15 +91,16 @@ def add_element( text: Optional[str] = None, *, attrs: Optional[dict] = None, - ): + ) -> "XmlCommandElement": node = SubElement(self._element, name, attrib=attrs) node.text = text return XmlCommandElement(node) - def set_attribute(self, name: str, value: str): + def set_attribute(self, name: str, value: str) -> "XmlCommandElement": self._element.set(name, value) + return self - def set_attributes(self, attrs: dict): + def set_attributes(self, attrs: dict[str, str]) -> "XmlCommandElement": """Set several attributes at once. Arguments: @@ -49,26 +109,47 @@ def set_attributes(self, attrs: dict): for key, value in attrs.items(): self._element.set(key, value) - def append_xml_str(self, xml_text: str): + return self + + def append_xml_str(self, xml_text: str) -> None: """Append a xml element in string format.""" - node = secET.fromstring(xml_text) + node = parse_xml(xml_text) self._element.append(node) def to_string(self) -> str: - return xmltostring(self._element).decode("utf-8") + return self.to_bytes().decode("utf-8") + + def to_bytes(self) -> bytes: + return xml_to_string(self._element) - def __str__(self): + def __str__(self) -> str: return self.to_string() + def __bytes__(self) -> bytes: + return self.to_bytes() + class XmlCommand(XmlCommandElement): - def __init__(self, name): - super().__init__(Element(name)) + def __init__(self, name: str) -> None: + super().__init__(create_element(name)) + + def add_filter( + self, + filter_string: Optional[str], + filter_id: Optional[Union[str, UUID]], + ) -> "XmlCommand": + if filter_string: + self.set_attribute("filter", filter_string) + + if filter_id: + self.set_attribute("filt_id", str(filter_id)) + + return self def pretty_print( - xml: Union[str, List[Union[Element, str]], Element], - file: IOBase = sys.stdout, + xml: Union[str, list[Union[Element, str]], Element], + file: Union[TextIO, IOBase] = sys.stdout, ): """Prints beautiful XML-Code @@ -85,31 +166,31 @@ def pretty_print( A IOBase type. Can be a File, StringIO, ... """ - if not isinstance(file, IOBase): + if not isinstance(file, (IOBase, TextIO)): raise TypeError( - f"Type needs to be from IOBase, not {type(file)}." + f"Type needs to be from IOBase or TextIO, not {type(file)}." ) from None if isinstance(xml, list): for item in xml: - if isxmlelement(item): + if is_xml_element(item): file.write( - xmltostring(item, pretty_print=True).decode( + xml_to_string(item, pretty_print=True).decode( sys.getdefaultencoding() + "\n" ) ) else: - file.write(item + "\n") - elif isxmlelement(xml): + file.write(str(item) + "\n") + elif is_xml_element(xml): file.write( - xmltostring(xml, pretty_print=True).decode( + xml_to_string(xml, pretty_print=True).decode( sys.getdefaultencoding() + "\n" ) ) elif isinstance(xml, str): - tree = secET.fromstring(xml) + tree = parse_xml(xml) file.write( - xmltostring(tree, pretty_print=True).decode( + xml_to_string(tree, pretty_print=True).decode( sys.getdefaultencoding() + "\n" ) ) @@ -117,22 +198,3 @@ def pretty_print( raise InvalidArgumentType( function=pretty_print.__name__, argument="xml", arg_type="" ) - - -def validate_xml_string(xml_string: str): - """Checks if the passed string contains valid XML - - Raises a GvmError if the XML is invalid. Otherwise the function just - returns. - - Arguments: - xml_string: XML string to validate - - Raises: - GvmError: The xml string did contain invalid XML - - """ - try: - secET.fromstring(xml_string) - except (DefusedXmlException, LxmlError) as e: - raise GvmError("Invalid XML", e) from e diff --git a/poetry.lock b/poetry.lock index 719b8f08e..0b5a2d951 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. [[package]] name = "alabaster" @@ -65,6 +65,21 @@ files = [ autohooks = ">=21.6.0" black = ">=20.8" +[[package]] +name = "autohooks-plugin-mypy" +version = "23.10.0" +description = "An autohooks plugin for python code static typing check with mypy" +optional = false +python-versions = ">=3.9,<4.0" +files = [ + {file = "autohooks_plugin_mypy-23.10.0-py3-none-any.whl", hash = "sha256:8ac36b74900b2f2456fec046126e564374acd6de2752d87255c6f71c4e6a73ff"}, + {file = "autohooks_plugin_mypy-23.10.0.tar.gz", hash = "sha256:ebefaa83074b662de38c914f6cac9f4f8e3452e36f54a5834df3f1590cc0c540"}, +] + +[package.dependencies] +autohooks = ">=21.7.0" +mypy = ">=0.910" + [[package]] name = "autohooks-plugin-ruff" version = "24.1.0" @@ -532,17 +547,6 @@ ssh = ["bcrypt (>=3.1.5)"] test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] test-randomorder = ["pytest-randomly"] -[[package]] -name = "defusedxml" -version = "0.7.1" -description = "XML bomb protection for Python stdlib modules" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, - {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, -] - [[package]] name = "docutils" version = "0.21.2" @@ -895,6 +899,20 @@ html5 = ["html5lib"] htmlsoup = ["BeautifulSoup4"] source = ["Cython (>=3.0.10)"] +[[package]] +name = "lxml-stubs" +version = "0.5.1" +description = "Type annotations for the lxml package" +optional = false +python-versions = "*" +files = [ + {file = "lxml-stubs-0.5.1.tar.gz", hash = "sha256:e0ec2aa1ce92d91278b719091ce4515c12adc1d564359dfaf81efa7d4feab79d"}, + {file = "lxml_stubs-0.5.1-py3-none-any.whl", hash = "sha256:1f689e5dbc4b9247cb09ae820c7d34daeb1fdbd1db06123814b856dae7787272"}, +] + +[package.extras] +test = ["coverage[toml] (>=7.2.5)", "mypy (>=1.2.0)", "pytest (>=7.3.0)", "pytest-mypy-plugins (>=1.10.1)"] + [[package]] name = "markdown-it-py" version = "3.0.0" @@ -999,6 +1017,53 @@ files = [ {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, ] +[[package]] +name = "mypy" +version = "1.10.0" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-1.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:da1cbf08fb3b851ab3b9523a884c232774008267b1f83371ace57f412fe308c2"}, + {file = "mypy-1.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:12b6bfc1b1a66095ab413160a6e520e1dc076a28f3e22f7fb25ba3b000b4ef99"}, + {file = "mypy-1.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e36fb078cce9904c7989b9693e41cb9711e0600139ce3970c6ef814b6ebc2b2"}, + {file = "mypy-1.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2b0695d605ddcd3eb2f736cd8b4e388288c21e7de85001e9f85df9187f2b50f9"}, + {file = "mypy-1.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:cd777b780312ddb135bceb9bc8722a73ec95e042f911cc279e2ec3c667076051"}, + {file = "mypy-1.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3be66771aa5c97602f382230165b856c231d1277c511c9a8dd058be4784472e1"}, + {file = "mypy-1.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8b2cbaca148d0754a54d44121b5825ae71868c7592a53b7292eeb0f3fdae95ee"}, + {file = "mypy-1.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ec404a7cbe9fc0e92cb0e67f55ce0c025014e26d33e54d9e506a0f2d07fe5de"}, + {file = "mypy-1.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e22e1527dc3d4aa94311d246b59e47f6455b8729f4968765ac1eacf9a4760bc7"}, + {file = "mypy-1.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:a87dbfa85971e8d59c9cc1fcf534efe664d8949e4c0b6b44e8ca548e746a8d53"}, + {file = "mypy-1.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a781f6ad4bab20eef8b65174a57e5203f4be627b46291f4589879bf4e257b97b"}, + {file = "mypy-1.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b808e12113505b97d9023b0b5e0c0705a90571c6feefc6f215c1df9381256e30"}, + {file = "mypy-1.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f55583b12156c399dce2df7d16f8a5095291354f1e839c252ec6c0611e86e2e"}, + {file = "mypy-1.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4cf18f9d0efa1b16478c4c129eabec36148032575391095f73cae2e722fcf9d5"}, + {file = "mypy-1.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:bc6ac273b23c6b82da3bb25f4136c4fd42665f17f2cd850771cb600bdd2ebeda"}, + {file = "mypy-1.10.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9fd50226364cd2737351c79807775136b0abe084433b55b2e29181a4c3c878c0"}, + {file = "mypy-1.10.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f90cff89eea89273727d8783fef5d4a934be2fdca11b47def50cf5d311aff727"}, + {file = "mypy-1.10.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fcfc70599efde5c67862a07a1aaf50e55bce629ace26bb19dc17cece5dd31ca4"}, + {file = "mypy-1.10.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:075cbf81f3e134eadaf247de187bd604748171d6b79736fa9b6c9685b4083061"}, + {file = "mypy-1.10.0-cp38-cp38-win_amd64.whl", hash = "sha256:3f298531bca95ff615b6e9f2fc0333aae27fa48052903a0ac90215021cdcfa4f"}, + {file = "mypy-1.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fa7ef5244615a2523b56c034becde4e9e3f9b034854c93639adb667ec9ec2976"}, + {file = "mypy-1.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3236a4c8f535a0631f85f5fcdffba71c7feeef76a6002fcba7c1a8e57c8be1ec"}, + {file = "mypy-1.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a2b5cdbb5dd35aa08ea9114436e0d79aceb2f38e32c21684dcf8e24e1e92821"}, + {file = "mypy-1.10.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:92f93b21c0fe73dc00abf91022234c79d793318b8a96faac147cd579c1671746"}, + {file = "mypy-1.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:28d0e038361b45f099cc086d9dd99c15ff14d0188f44ac883010e172ce86c38a"}, + {file = "mypy-1.10.0-py3-none-any.whl", hash = "sha256:f8c083976eb530019175aabadb60921e73b4f45736760826aa1689dda8208aee"}, + {file = "mypy-1.10.0.tar.gz", hash = "sha256:3d087fcbec056c4ee34974da493a826ce316947485cef3901f511848e687c131"}, +] + +[package.dependencies] +mypy-extensions = ">=1.0.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=4.1.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +install-types = ["pip"] +mypyc = ["setuptools (>=50)"] +reports = ["lxml"] + [[package]] name = "mypy-extensions" version = "1.0.0" @@ -1459,6 +1524,20 @@ files = [ {file = "tomlkit-0.12.5.tar.gz", hash = "sha256:eef34fba39834d4d6b73c9ba7f3e4d1c417a4e56f89a7e96e090dd0d24b8fb3c"}, ] +[[package]] +name = "types-paramiko" +version = "3.4.0.20240423" +description = "Typing stubs for paramiko" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-paramiko-3.4.0.20240423.tar.gz", hash = "sha256:aaa98dda232c47886563d66743d3a8b66c432790c596bc3bdd3f17f91be2a8c1"}, + {file = "types_paramiko-3.4.0.20240423-py3-none-any.whl", hash = "sha256:c56e0d43399a1b909901b1e0375e0ff6ee62e16cd6e00695024abc2e9fe02035"}, +] + +[package.dependencies] +cryptography = ">=37.0.0" + [[package]] name = "typing-extensions" version = "4.12.2" @@ -1505,4 +1584,4 @@ test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", [metadata] lock-version = "2.0" python-versions = "^3.9" -content-hash = "18f5d6364ac26d77998f2a840050360d687bf8d3047d30a6b3cd2b44c3198495" +content-hash = "6b87db303635388552fb0d240fcda7d8e998577edd951f068a061132cde19119" diff --git a/pyproject.toml b/pyproject.toml index 63e15943e..cf32595a8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,7 +31,6 @@ packages = [{ include = "gvm" }, { include = "tests", format = "sdist" }] python = "^3.9" paramiko = ">=2.7.1" lxml = ">=4.5.0" -defusedxml = ">=0.6" typing-extensions = ">=4.9.0" [tool.poetry.group.dev.dependencies] @@ -39,9 +38,12 @@ coverage = ">=7.2" sphinx = ">=5.3.0" autohooks-plugin-ruff = ">=24.1.0" autohooks-plugin-black = ">=22.7.0" +autohooks-plugin-mypy = ">=22.7.0" black = ">=22.6.0" pontos = ">=22.7.2" furo = ">=2022.6.21" +lxml-stubs = "^0.5.1" +types-paramiko = "^3.4.0.20240205" [tool.black] line-length = 80 @@ -75,3 +77,9 @@ source = ["gvm"] [tool.pontos.version] version-module-file = "gvm/__version__.py" + +[tool.mypy] +files = "gvm" +ignore_missing_imports = true +explicit_package_bases = true +allow_redefinition = true diff --git a/tests/connections/test_debug_connection.py b/tests/connections/test_debug_connection.py new file mode 100644 index 000000000..efe051228 --- /dev/null +++ b/tests/connections/test_debug_connection.py @@ -0,0 +1,19 @@ +# SPDX-FileCopyrightText: 2020-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.connections import DebugConnection, GvmConnection +from gvm.connections._connection import AbstractGvmConnection + + +class TestConnection(AbstractGvmConnection): + def connect(self) -> None: + pass + + +class DebugConnectionTestCase(unittest.TestCase): + def test_is_gvm_connection(self): + connection = DebugConnection(TestConnection()) + self.assertTrue(isinstance(connection, GvmConnection)) diff --git a/tests/connections/test_gvm_connection.py b/tests/connections/test_gvm_connection.py index 48b415062..041a24f8d 100644 --- a/tests/connections/test_gvm_connection.py +++ b/tests/connections/test_gvm_connection.py @@ -4,27 +4,16 @@ # import unittest -from unittest.mock import patch +from unittest.mock import MagicMock from gvm.connections import ( DEFAULT_TIMEOUT, - AbstractGvmConnection, - DebugConnection, GvmConnection, - XmlReader, ) +from gvm.connections._connection import AbstractGvmConnection from gvm.errors import GvmError -class XmlReaderTestCase(unittest.TestCase): - def test_is_end_xml_false(self): - reader = XmlReader() - reader.start_xml() - - false = reader.is_end_xml() - self.assertFalse(false) - - class TestConnection(AbstractGvmConnection): def connect(self) -> None: pass @@ -34,29 +23,35 @@ class GvmConnectionTestCase(unittest.TestCase): # pylint: disable=protected-access def test_init_no_args(self): connection = TestConnection() - self.check_for_default_values(connection) + + self.assertIsNone(connection._socket) + self.assertEqual(connection._timeout, DEFAULT_TIMEOUT) def test_init_with_none(self): connection = TestConnection(timeout=None) - self.check_for_default_values(connection) - def check_for_default_values(self, gvm_connection: GvmConnection): - self.assertIsNone(gvm_connection._socket) - self.assertEqual(gvm_connection._timeout, DEFAULT_TIMEOUT) + self.assertIsNone(connection._socket) + self.assertEqual(connection._timeout, DEFAULT_TIMEOUT) + + def test_read_no_data(self): + read_mock = MagicMock() + read_mock.return_value = None - @patch("gvm.connections.AbstractGvmConnection._read") - def test_read_no_data(self, _read_mock): - _read_mock.return_value = None connection = TestConnection() + connection._read = read_mock + with self.assertRaises(GvmError, msg="Remote closed the connection"): connection.read() - @patch("gvm.connections.AbstractGvmConnection._read") - def test_read_trigger_timeout(self, _read_mock): + def test_read_trigger_timeout(self): # mocking the response into two parts, so we run into the timeout # check in the loop - _read_mock.side_effect = [b"xyz", b""] + read_mock = MagicMock() + read_mock.side_effect = [b"xyz", b""] + connection = TestConnection(timeout=0) + connection._read = read_mock + with self.assertRaises( GvmError, msg="Timeout while reading the response" ): @@ -65,9 +60,3 @@ def test_read_trigger_timeout(self, _read_mock): def test_is_gvm_connection(self): connection = TestConnection() self.assertTrue(isinstance(connection, GvmConnection)) - - -class DebugConnectionTestCase(unittest.TestCase): - def test_is_gvm_connection(self): - connection = DebugConnection(TestConnection()) - self.assertTrue(isinstance(connection, GvmConnection)) diff --git a/tests/connections/test_ssh_connection.py b/tests/connections/test_ssh_connection.py index 75d5fe70b..60d3bcada 100644 --- a/tests/connections/test_ssh_connection.py +++ b/tests/connections/test_ssh_connection.py @@ -3,11 +3,10 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -import os import unittest from io import StringIO from pathlib import Path -from unittest.mock import Mock, patch +from unittest.mock import MagicMock, Mock, patch import paramiko @@ -23,19 +22,22 @@ from gvm.errors import GvmError +class AbortException(Exception): + """Just for testing purposes""" + + class SSHConnectionTestCase(unittest.TestCase): # pylint: disable=protected-access, invalid-name def setUp(self): self.known_hosts_file = Path("known_hosts") - with self.known_hosts_file.open("a", encoding="utf-8") as fp: - fp.write( - "127.0.0.1 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBOZWi" - "fs+DoMqIa5Nr0wiVrzQNpMbUwaLzuSTN6rNrYA\n" - ) + self.known_hosts_file.write_text( + "127.0.0.1 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBOZWi" + "fs+DoMqIa5Nr0wiVrzQNpMbUwaLzuSTN6rNrYA\n", + encoding="utf-8", + ) def tearDown(self): - if self.known_hosts_file.exists(): - self.known_hosts_file.unlink() + self.known_hosts_file.unlink(missing_ok=True) def test_init_no_args(self): ssh_connection = SSHConnection() @@ -49,7 +51,9 @@ def test_init_with_none(self): self.check_ssh_connection_for_default_values(ssh_connection) - def check_ssh_connection_for_default_values(self, ssh_connection): + def check_ssh_connection_for_default_values( + self, ssh_connection: SSHConnection + ): self.assertIsInstance(ssh_connection, SSHConnection) self.assertEqual(ssh_connection.hostname, DEFAULT_HOSTNAME) self.assertEqual(ssh_connection.port, DEFAULT_SSH_PORT) @@ -87,7 +91,7 @@ def test_connect(self): ssh_connection.disconnect() def test_connect_auto_accept_host(self): - with patch("paramiko.SSHClient") as SSHClientMock: + with patch("paramiko.SSHClient", autospec=True) as SSHClientMock: client_mock = SSHClientMock.return_value client_mock.exec_command.return_value = ["a", "b", "c"] ssh_connection = SSHConnection( @@ -116,8 +120,7 @@ def test_connect_unknown_host(self): ssh_connection.connect() def test_connect_denied_known_hosts_file(self): - if os.path.exists(self.known_hosts_file): - os.chmod(self.known_hosts_file, 0000) + self.known_hosts_file.chmod(0000) ssh_connection = SSHConnection( hostname="0.0.0.1", known_hosts_file=self.known_hosts_file @@ -132,8 +135,7 @@ def test_connect_denied_known_hosts_file(self): ssh_connection.connect() def test_connect_no_known_hosts_file(self): - if os.path.exists(self.known_hosts_file): - os.remove(self.known_hosts_file) + self.known_hosts_file.unlink(missing_ok=True) ssh_connection = SSHConnection( hostname="0.0.0.1", @@ -150,8 +152,8 @@ def test_connect_no_known_hosts_file(self): ssh_connection.connect() @patch("builtins.print") - @patch("builtins.input") - def test_connect_adding_and_save_hostkey(self, input_mock, _print_mock): + def test_connect_adding_and_save_hostkey(self, _print_mock): + input_mock = MagicMock(spec=input) key_io = StringIO( """-----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW @@ -167,9 +169,10 @@ def test_connect_adding_and_save_hostkey(self, input_mock, _print_mock): hostname = "0.0.0.0" input_mock.side_effect = ["yes", "yes"] ssh_connection = SSHConnection( - hostname=hostname, known_hosts_file=self.known_hosts_file + hostname=hostname, + known_hosts_file=self.known_hosts_file, + input=input_mock, ) - ssh_connection._socket = paramiko.SSHClient() keys = self.known_hosts_file.read_text(encoding="utf-8") self.assertEqual( keys, @@ -187,7 +190,7 @@ def test_connect_adding_and_save_hostkey(self, input_mock, _print_mock): self.assertEqual( cm.output, [ - "INFO:gvm.connections:Warning: " + "INFO:gvm.connections.ssh:Warning: " f"Permanently added '{hostname}' ({key_type}) to " "the list of known hosts." ], @@ -200,10 +203,8 @@ def test_connect_adding_and_save_hostkey(self, input_mock, _print_mock): ) @patch("builtins.print") - @patch("builtins.input") - def test_connect_adding_and_dont_save_hostkey( - self, input_mock, _print_mock - ): + def test_connect_adding_and_dont_save_hostkey(self, _print_mock): + input_mock = MagicMock(spec=input) key_io = StringIO( """-----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW @@ -218,10 +219,12 @@ def test_connect_adding_and_dont_save_hostkey( key_type = key.get_name().replace("ssh-", "").upper() hostname = "0.0.0.0" input_mock.side_effect = ["yes", "no"] + ssh_connection = SSHConnection( - hostname=hostname, known_hosts_file=self.known_hosts_file + hostname=hostname, + known_hosts_file=self.known_hosts_file, + input=input_mock, ) - ssh_connection._socket = paramiko.SSHClient() keys = self.known_hosts_file.read_text(encoding="utf-8") self.assertEqual( keys, @@ -239,7 +242,7 @@ def test_connect_adding_and_dont_save_hostkey( self.assertEqual( cm.output, [ - "INFO:gvm.connections:Warning: " + "INFO:gvm.connections.ssh:Warning: " f"Host '{hostname}' ({key_type}) not added to " "the list of known hosts." ], @@ -251,9 +254,9 @@ def test_connect_adding_and_dont_save_hostkey( "fs+DoMqIa5Nr0wiVrzQNpMbUwaLzuSTN6rNrYA\n", ) - @patch("builtins.input") - @patch("sys.stdout", new_callable=StringIO) - def test_connect_wrong_input(self, stdout_mock, input_mock): + def test_connect_wrong_input(self): + input_mock = MagicMock(spec=input) + stdout_mock = StringIO() key_io = StringIO( """-----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW @@ -270,10 +273,11 @@ def test_connect_wrong_input(self, stdout_mock, input_mock): inputs = ["asd", "yes", "yoo", "no"] input_mock.side_effect = inputs ssh_connection = SSHConnection( - hostname=hostname, known_hosts_file=self.known_hosts_file + hostname=hostname, + known_hosts_file=self.known_hosts_file, + input=input_mock, + file=stdout_mock, ) - ssh_connection._socket = paramiko.SSHClient() - with self.assertLogs("gvm.connections", level="INFO") as cm: hostkeys = paramiko.HostKeys(filename=str(self.known_hosts_file)) ssh_connection._ssh_authentication_input_loop( @@ -284,7 +288,7 @@ def test_connect_wrong_input(self, stdout_mock, input_mock): self.assertEqual( cm.output, [ - "INFO:gvm.connections:Warning: " + "INFO:gvm.connections.ssh:Warning: " f"Host '{hostname}' ({key_type}) not added to " "the list of known hosts." ], @@ -301,8 +305,10 @@ def test_connect_wrong_input(self, stdout_mock, input_mock): "Please type 'yes' or 'no': ", ) - @patch("builtins.input") - def test_user_denies_auth(self, input_mock): + def test_user_denies_auth(self): + input_mock = MagicMock(spec=input) + stdout_mock = StringIO() + exit_mock = MagicMock(side_effect=AbortException("Exit called")) key_io = StringIO( """-----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW @@ -317,18 +323,23 @@ def test_user_denies_auth(self, input_mock): hostname = "0.0.0.0" input_mock.return_value = "no" ssh_connection = SSHConnection( - hostname=hostname, known_hosts_file=self.known_hosts_file + hostname=hostname, + known_hosts_file=self.known_hosts_file, + input=input_mock, + exit=exit_mock, + file=stdout_mock, ) - ssh_connection._socket = paramiko.SSHClient() - - with self.assertRaises( - SystemExit, msg="User denied key. Host key verification failed." - ): - hostkeys = paramiko.HostKeys(filename=str(self.known_hosts_file)) + hostkeys = paramiko.HostKeys(filename=str(self.known_hosts_file)) + with self.assertRaisesRegex(AbortException, "^Exit called"): ssh_connection._ssh_authentication_input_loop( - hostkeys=hostkeys, key=key + hostkeys=hostkeys, + key=key, ) + exit_mock.assert_called_once_with( + "User denied key. Host key verification failed." + ) + def test_disconnect(self): with patch("paramiko.SSHClient") as SSHClientMock: client_mock = SSHClientMock.return_value @@ -350,23 +361,6 @@ def test_disconnect(self): type(ssh_connection._stdout) with self.assertRaises(AttributeError): type(ssh_connection._stderr) - with self.assertRaises(AttributeError): - type(ssh_connection._socket) - - with self.assertRaises(AttributeError): - with self.assertLogs("gvm.connections", level="INFO") as cm: - # disconnect twice should not work ... - ssh_connection.disconnect() - self.assertEqual( - cm.output, - [ - "Connection might already be" - " closed. No socket found.", - ], - ) - - ssh_connection._socket = None - ssh_connection.disconnect() def test_disconnect_os_error(self): with patch("paramiko.SSHClient") as SSHClientMock: diff --git a/tests/connections/test_tls_connection.py b/tests/connections/test_tls_connection.py index 7b1cf9dd6..cce016d80 100644 --- a/tests/connections/test_tls_connection.py +++ b/tests/connections/test_tls_connection.py @@ -16,7 +16,6 @@ class TLSConnectionTestCase(unittest.TestCase): - # pylint: disable=protected-access, invalid-name def test_init_no_args(self): connection = TLSConnection() self.check_default_values(connection) diff --git a/tests/connections/test_unix_socket_connection.py b/tests/connections/test_unix_socket_connection.py index 4568f78e6..0d8eaeee9 100644 --- a/tests/connections/test_unix_socket_connection.py +++ b/tests/connections/test_unix_socket_connection.py @@ -3,12 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -import os import socketserver import tempfile import threading import unittest import uuid +from pathlib import Path from unittest.mock import patch from gvm.connections import ( @@ -22,9 +22,7 @@ class DummyRequestHandler(socketserver.BaseRequestHandler): def handle(self): - response = bytes( - '', "utf-8" - ) + response = b'' self.request.sendall(response) @@ -37,48 +35,40 @@ class ThreadedUnixStreamServer( class UnixSocketConnectionTestCase(unittest.TestCase): # pylint: disable=protected-access, invalid-name def setUp(self): - self.socketname = f"{tempfile.gettempdir()}/{str(uuid.uuid4())}.sock" - self.sockserv = ThreadedUnixStreamServer( - self.socketname, DummyRequestHandler + self.socket_name = f"{tempfile.gettempdir()}/{str(uuid.uuid4())}.sock" + self.socket_path = Path(self.socket_name) + self.socket_server = ThreadedUnixStreamServer( + self.socket_name, DummyRequestHandler ) self.server_thread = threading.Thread( - target=self.sockserv.serve_forever + target=self.socket_server.serve_forever ) self.server_thread.daemon = True self.server_thread.start() def tearDown(self): - self.sockserv.shutdown() - self.sockserv.server_close() - os.unlink(self.socketname) + self.socket_server.server_close() + self.socket_server.shutdown() + self.server_thread.join(60.0) + self.socket_path.unlink(missing_ok=True) def test_unix_socket_connection_connect_read(self): connection = UnixSocketConnection( - path=self.socketname, timeout=DEFAULT_TIMEOUT + path=self.socket_name, timeout=DEFAULT_TIMEOUT ) connection.connect() resp = connection.read() - self.assertEqual(resp, '') + self.assertEqual(resp, b'') connection.disconnect() def test_unix_socket_connection_connect_send_bytes_read(self): connection = UnixSocketConnection( - path=self.socketname, timeout=DEFAULT_TIMEOUT - ) - connection.connect() - connection.send(bytes("", "utf-8")) - resp = connection.read() - self.assertEqual(resp, '') - connection.disconnect() - - def test_unix_socket_connection_connect_send_str_read(self): - connection = UnixSocketConnection( - path=self.socketname, timeout=DEFAULT_TIMEOUT + path=self.socket_name, timeout=DEFAULT_TIMEOUT ) connection.connect() - connection.send("") + connection.send(b"") resp = connection.read() - self.assertEqual(resp, '') + self.assertEqual(resp, b'') connection.disconnect() def test_unix_socket_connect_file_not_found(self): @@ -89,20 +79,20 @@ def test_unix_socket_connect_file_not_found(self): def test_unix_socket_connect_could_not_connect(self): connection = UnixSocketConnection( - path=self.socketname, timeout=DEFAULT_TIMEOUT + path=self.socket_name, timeout=DEFAULT_TIMEOUT ) with patch("socket.socket.connect") as ConnectMock: connect_mock = ConnectMock connect_mock.side_effect = ConnectionError with self.assertRaises( - GvmError, msg=f"Could not connect to socket {self.socketname}" + GvmError, msg=f"Could not connect to socket {self.socket_name}" ): connection.connect() connection.disconnect() def test_unix_socket_send_unconnected_socket(self): connection = UnixSocketConnection( - path=self.socketname, timeout=DEFAULT_TIMEOUT + path=self.socket_name, timeout=DEFAULT_TIMEOUT ) with self.assertRaises(GvmError, msg="Socket is not connected"): connection.send("/") diff --git a/tests/protocols/__init__.py b/tests/protocols/__init__.py index fc7f7d935..1cd555d43 100644 --- a/tests/protocols/__init__.py +++ b/tests/protocols/__init__.py @@ -4,7 +4,9 @@ # import unittest +from typing import Any, Type +from gvm.protocols._protocol import GvmProtocol from tests import CallableMock @@ -14,12 +16,12 @@ def __init__(self): self.disconnect = CallableMock("disconnect") self.send = CallableMock("send") self.read = CallableMock("read") - self.read.return_value('') + self.read.return_value(b'') self.finish_send = CallableMock("finish_send") class GmpTestCase(unittest.TestCase): - gmp_class = None + gmp_class: Type[GvmProtocol[Any]] def setUp(self): self.connection = MockConnection() diff --git a/tests/protocols/core/__init__.py b/tests/protocols/core/__init__.py new file mode 100644 index 000000000..5197e3be9 --- /dev/null +++ b/tests/protocols/core/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later diff --git a/tests/protocols/core/test_connection.py b/tests/protocols/core/test_connection.py new file mode 100644 index 000000000..c60f2baf9 --- /dev/null +++ b/tests/protocols/core/test_connection.py @@ -0,0 +1,146 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import GvmError +from gvm.protocols.core import Connection, InvalidStateError + + +class RequestMock: + def __init__(self, data: bytes) -> None: + self._data = data + + def __bytes__(self) -> bytes: + return self._data + + +class ConnectionTestCase(unittest.TestCase): + def test_send_request(self) -> None: + request = RequestMock(b"") + connection = Connection() + + data = connection.send(request) + self.assertEqual(data, b"") + + def test_receive_data(self) -> None: + request = RequestMock(b"") + connection = Connection() + + connection.send(request) + response = connection.receive_data(b"') + + self.assertIsNotNone(response) + self.assertTrue(response.is_success) # type: ignore + + another_request = RequestMock(b"") + connection.send(another_request) + + response = connection.receive_data(b"') + + self.assertIsNotNone(response) + self.assertTrue(response.is_success) # type: ignore + + def test_receive_invalid_data(self) -> None: + request = RequestMock(b"") + connection = Connection() + + connection.send(request) + with self.assertRaisesRegex( + GvmError, + "^Cannot parse XML response. Response data read b''$", + ): + connection.receive_data(b"") + + def test_error_state_close(self) -> None: + request = RequestMock(b"") + connection = Connection() + + connection.send(request) + with self.assertRaisesRegex( + GvmError, + "^Cannot parse XML response. Response data read b''$", + ): + connection.receive_data(b"") + + with self.assertRaisesRegex( + InvalidStateError, + "^The connection is in an error state. Please close the connection.$", + ): + connection.receive_data(b"") + + with self.assertRaisesRegex( + InvalidStateError, + "^The connection is in an error state. Please close the connection.$", + ): + connection.send(request) + + connection.close() + connection.send(request) + + def test_send_when_receiving_data(self) -> None: + request = RequestMock(b"") + connection = Connection() + + connection.send(request) + connection.receive_data(b" None: + request = RequestMock(b"") + connection = Connection() + + connection.close() + + data = connection.send(request) + self.assertEqual(data, b"") + + def test_close_after_send(self) -> None: + request = RequestMock(b"") + connection = Connection() + + data = connection.send(request) + self.assertEqual(data, b"") + + connection.close() + + with self.assertRaisesRegex( + InvalidStateError, + "^Invalid State$", + ): + connection.receive_data(b"") + + def test_close_after_receive_data(self) -> None: + request = RequestMock(b"") + connection = Connection() + + data = connection.send(request) + self.assertEqual(data, b"") + + connection.receive_data(b"') + + data = connection.send(request) + self.assertEqual(data, b"") diff --git a/tests/protocols/core/test_request.py b/tests/protocols/core/test_request.py new file mode 100644 index 000000000..f6da4d81f --- /dev/null +++ b/tests/protocols/core/test_request.py @@ -0,0 +1,24 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.protocols.core import Request + + +class RequestMock: + def __init__(self, data: bytes) -> None: + self._data = data + + def __bytes__(self) -> bytes: + return self._data + + +class RequestTestCase(unittest.TestCase): + def test_request(self) -> None: + # request is just a protocol and can be implemented by several classes + request = RequestMock(b"some data") + self.assertIsInstance(request, Request) + + self.assertEqual(bytes(request), b"some data") diff --git a/tests/protocols/core/test_response.py b/tests/protocols/core/test_response.py new file mode 100644 index 000000000..1830cddb0 --- /dev/null +++ b/tests/protocols/core/test_response.py @@ -0,0 +1,103 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.protocols.core import Response, StatusError +from gvm.xml import Element, XmlError + + +class RequestMock: + def __init__(self, data: bytes) -> None: + self._data = data + + def __bytes__(self) -> bytes: + return self._data + + +class ResponseTestCase(unittest.TestCase): + + def test_data(self) -> None: + request = RequestMock(b"") + response = Response(data=b"", request=request) + + self.assertEqual(response.data, b"") + + def test_bytes(self) -> None: + request = RequestMock(b"") + response = Response(data=b"", request=request) + + self.assertEqual(bytes(response), b"") + + def test_request(self) -> None: + request = RequestMock(b"") + response = Response(data=b"", request=request) + + self.assertEqual(response.request, request) + + def test_status_code(self): + request = RequestMock(b"") + response = Response(data=b"", request=request) + self.assertIsNone(response.status_code) + + response = Response(data=b'', request=request) + self.assertIsNone(response.status_code) + + response = Response(data=b'', request=request) + self.assertEqual(response.status_code, 123) + + def test_is_success(self): + request = RequestMock(b"") + response = Response(data=b"", request=request) + self.assertFalse(response.is_success) + + response = Response(data=b'', request=request) + self.assertFalse(response.is_success) + + response = Response(data=b'', request=request) + self.assertFalse(response.is_success) + + response = Response(data=b'', request=request) + self.assertTrue(response.is_success) + + def test_raise_for_status(self): + request = RequestMock(b"") + response = Response(data=b"", request=request) + + with self.assertRaisesRegex(StatusError, "^Invalid status code None$"): + response.raise_for_status() + + response = Response(data=b'', request=request) + with self.assertRaisesRegex(StatusError, "^Invalid status code None$"): + response.raise_for_status() + + response = Response(data=b'', request=request) + with self.assertRaisesRegex(StatusError, "^Invalid status code 123$"): + response.raise_for_status() + + response = Response(data=b'', request=request) + self.assertIs(response.raise_for_status(), response) + + def test_xml(self): + request = RequestMock(b"") + response = Response( + data=b'', request=request + ) + + xml = response.xml() + self.assertIsInstance(xml, Element) + + self.assertEqual(xml.tag, "response") + sub_element = xml[0] + self.assertEqual(sub_element.tag, "some") + self.assertEqual(sub_element.attrib["data"], "lorem") + + def test_invalid_xml(self): + request = RequestMock(b"") + response = Response(data=b"", request=request) + + with self.assertRaisesRegex( + XmlError, "^Invalid XML b''. Error was .*$" + ): + response.xml() diff --git a/tests/protocols/core/test_states.py b/tests/protocols/core/test_states.py new file mode 100644 index 000000000..7e03e6d82 --- /dev/null +++ b/tests/protocols/core/test_states.py @@ -0,0 +1,172 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest +from unittest.mock import MagicMock + +from gvm.protocols.core import InvalidStateError, Response +from gvm.protocols.core._connection import ( + AwaitingResponseState, + Context, + ErrorState, + InitialState, + ReceivingDataState, +) + + +class RequestMock: + def __init__(self, data: bytes) -> None: + self._data = data + + def __bytes__(self) -> bytes: + return self._data + + +class InitialStateTestCase(unittest.TestCase): + def test_receive_data(self) -> None: + context = MagicMock(spec=Context) + state = InitialState() + state.__set_context__(context) + + with self.assertRaisesRegex(InvalidStateError, "Invalid State"): + state.receive_data(b"some data") + + def test_close(self) -> None: + context = MagicMock(spec=Context) + state = InitialState() + state.__set_context__(context) + + state.close() + + context.__set_state__.assert_not_called() + + def test_send(self) -> None: + context = MagicMock(spec=Context) + state = InitialState() + state.__set_context__(context) + request = RequestMock(b"some data") + + data = state.send(request) + self.assertEqual(data, b"some data") + + self.assertIsInstance( + context.__set_state__.call_args[0][0], AwaitingResponseState + ) + + +class AwaitingResponseStateTestCase(unittest.TestCase): + + def test_receive_data(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = AwaitingResponseState(request) + state.__set_context__(context) + + response = state.receive_data(b"") + self.assertIsNone(response) + + self.assertIsInstance( + context.__set_state__.call_args[0][0], ReceivingDataState + ) + + def test_close(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = AwaitingResponseState(request) + state.__set_context__(context) + + state.close() + + self.assertIsInstance( + context.__set_state__.call_args[0][0], InitialState + ) + + def test_send(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = AwaitingResponseState(request) + state.__set_context__(context) + + with self.assertRaisesRegex(InvalidStateError, "Invalid State"): + another_request = RequestMock(b"") + state.send(another_request) + + +class ErrorStateTestCase(unittest.TestCase): + + def test_receive_data(self) -> None: + context = MagicMock(spec=Context) + state = ErrorState() + state.__set_context__(context) + + with self.assertRaisesRegex( + InvalidStateError, + "^The connection is in an error state. Please close the connection.$", + ): + state.receive_data(b"some data") + + def test_close(self) -> None: + context = MagicMock(spec=Context) + state = ErrorState() + state.__set_context__(context) + + state.close() + + self.assertIsInstance( + context.__set_state__.call_args[0][0], InitialState + ) + + def test_send(self) -> None: + context = MagicMock(spec=Context) + state = ErrorState() + state.__set_context__(context) + + with self.assertRaisesRegex( + InvalidStateError, + "^The connection is in an error state. Please close the connection.$", + ): + state.receive_data(b"some data") + + +class ReceivingDataStateTestCase(unittest.TestCase): + + def test_receive_data(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = ReceivingDataState(request) + state.__set_context__(context) + + response = state.receive_data(b"") + self.assertIsNone(response) + + response = state.receive_data(b"") + self.assertIsNotNone(response) + self.assertIsInstance(response, Response) + self.assertEqual(response.data, b"") # type: ignore + + self.assertIsInstance( + context.__set_state__.call_args[0][0], InitialState + ) + + def test_close(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = ReceivingDataState(request) + state.__set_context__(context) + + state.close() + + self.assertIsInstance( + context.__set_state__.call_args[0][0], InitialState + ) + + def test_send(self) -> None: + context = MagicMock(spec=Context) + request = RequestMock(b"") + state = ReceivingDataState(request) + state.__set_context__(context) + + with self.assertRaisesRegex(InvalidStateError, "Invalid State"): + another_request = RequestMock(b"") + state.send(another_request) diff --git a/tests/protocols/core/test_xml_reader.py b/tests/protocols/core/test_xml_reader.py new file mode 100644 index 000000000..b94f7c6e6 --- /dev/null +++ b/tests/protocols/core/test_xml_reader.py @@ -0,0 +1,16 @@ +# SPDX-FileCopyrightText: 2020-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.protocols.core._connection import XmlReader + + +class XmlReaderTestCase(unittest.TestCase): + def test_is_end_xml_false(self): + reader = XmlReader() + reader.start_xml() + + false = reader.is_end_xml() + self.assertFalse(false) diff --git a/tests/protocols/gmp/requests/__init__.py b/tests/protocols/gmp/requests/__init__.py new file mode 100644 index 000000000..5197e3be9 --- /dev/null +++ b/tests/protocols/gmp/requests/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later diff --git a/tests/protocols/gmp/requests/test_version.py b/tests/protocols/gmp/requests/test_version.py new file mode 100644 index 000000000..751f25be9 --- /dev/null +++ b/tests/protocols/gmp/requests/test_version.py @@ -0,0 +1,16 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.protocols.core import Request +from gvm.protocols.gmp.requests import Version + + +class VersionTestCase(unittest.TestCase): + def test_version(self) -> None: + request = Version.get_version() + + self.assertIsInstance(request, Request) + self.assertEqual(bytes(request), b"") diff --git a/tests/protocols/gmp/requests/v224/__init__.py b/tests/protocols/gmp/requests/v224/__init__.py new file mode 100644 index 000000000..5197e3be9 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later diff --git a/tests/protocols/gmp/requests/v224/test_aggregates.py b/tests/protocols/gmp/requests/v224/test_aggregates.py new file mode 100644 index 000000000..77bc7dace --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_aggregates.py @@ -0,0 +1,350 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument +from gvm.protocols.core import Request +from gvm.protocols.gmp.requests.v224 import ( + Aggregates, + AggregateStatistic, + EntityType, + SortOrder, +) + + +class AggregatesTestCase(unittest.TestCase): + def test_get_aggregates(self): + """ + Test basic get_aggregates calls with only resource_type except special + cases for audit, policy, scan_config and task. + """ + request = Aggregates.get_aggregates(EntityType.ALERT) + + self.assertIsInstance(request, Request) + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates( + resource_type=EntityType.CERT_BUND_ADV + ) + + self.assertEqual( + bytes(request), b'' + ) + + request = Aggregates.get_aggregates(EntityType.CPE) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.CVE) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.DFN_CERT_ADV) + + self.assertEqual( + bytes(request), b'' + ) + + request = Aggregates.get_aggregates(EntityType.HOST) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.NOTE) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.NVT) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.OPERATING_SYSTEM) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.OVALDEF) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.OVERRIDE) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.REPORT) + + self.assertEqual(bytes(request), b'') + + request = Aggregates.get_aggregates(EntityType.RESULT) + + self.assertEqual(bytes(request), b'') + + def test_get_aggregates_resource_types_with_usage_type(self): + """ + Test special cases of resource_type in get_aggregates calls that + should add a usage_type parameter: audit, policy, scan_config and task. + """ + request = Aggregates.get_aggregates(EntityType.AUDIT) + + self.assertEqual( + bytes(request), b'' + ) + + request = Aggregates.get_aggregates(EntityType.POLICY) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Aggregates.get_aggregates(EntityType.SCAN_CONFIG) + + self.assertEqual( + bytes(request), b'' + ) + + request = Aggregates.get_aggregates(EntityType.TASK) + + self.assertEqual( + bytes(request), b'' + ) + + def test_get_aggregates_missing_resource_type(self): + """ + Test get_aggregates calls with missing resource_type + """ + with self.assertRaises(RequiredArgument): + Aggregates.get_aggregates(resource_type=None) + + with self.assertRaises(RequiredArgument): + Aggregates.get_aggregates(resource_type="") + + with self.assertRaises(RequiredArgument): + Aggregates.get_aggregates("") + + def test_get_aggregates_invalid_resource_type(self): + """ + Test get_aggregates calls with invalid resource_type + """ + with self.assertRaises(InvalidArgument): + Aggregates.get_aggregates(resource_type="foo") + + def test_get_aggregates_sort_criteria(self): + """ + Test get_aggregates calls with sort_criteria given as strings + """ + request = Aggregates.get_aggregates( + EntityType.NVT, + group_column="family", + sort_criteria=[ + {"field": "severity", "stat": "mean", "order": "descending"}, + {"stat": "count", "order": "descending"}, + {"field": "family", "order": "ascending"}, + ], + data_columns=["severity"], + ) + + self.assertEqual( + bytes(request), + b'' + b'' + b'' + b'' + b"severity" + b"", + ) + + def test_get_aggregates_sort_criteria_enum(self): + """ + Test get_aggregates calls with sort_criteria given as enums + """ + request = Aggregates.get_aggregates( + EntityType.NVT, + group_column="family", + sort_criteria=[ + { + "field": "severity", + "stat": AggregateStatistic.MEAN, + "order": SortOrder.DESCENDING, + } + ], + data_columns=["severity"], + ) + + self.assertEqual( + bytes(request), + b'' + b'' + b"severity" + b"", + ) + + def test_get_aggregates_invalid_sort_criteria(self): + """ + Test get_aggregates calls with invalid sort_criteria + """ + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, sort_criteria="INVALID" + ) + + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, sort_criteria=["INVALID"] + ) + + with self.assertRaisesRegex( + InvalidArgument, + "^Invalid argument INVALID. Allowed values are COUNT,C_COUNT,C_SUM," + "MAX,MEAN,MIN,SUM,TEXT,VALUE.$", + ): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, + sort_criteria=[{"stat": "INVALID"}], + ) + + with self.assertRaises(InvalidArgument): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, + sort_criteria=[{"order": "INVALID"}], + ) + + def test_get_aggregates_group_limits(self): + """ + Test get_aggregates calls with group limits (first_group, max_groups) + """ + request = Aggregates.get_aggregates( + EntityType.CPE, first_group=20, max_groups=25 + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_aggregates_invalid_group_limits(self): + """ + Test get_aggregates calls with invalid group limits + """ + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + EntityType.CPE, first_group="INVALID", max_groups=25 + ) + + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + EntityType.CPE, first_group=1, max_groups="INVALID" + ) + + def test_get_aggregates_data_columns(self): + """ + Test get_aggregates calls with data_columns + """ + request = Aggregates.get_aggregates( + EntityType.CPE, data_columns=["severity", "cves"] + ) + + self.assertEqual( + bytes(request), + b'' + b"severity" + b"cves" + b"", + ) + + def test_get_aggregates_invalid_data_columns(self): + """ + Test get_aggregates calls with invalid data_columns + """ + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, data_columns=123 + ) + + def test_get_aggregates_group_column(self): + """ + Test get_aggregates calls with group_column + """ + request = Aggregates.get_aggregates( + EntityType.NVT, group_column="family" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_aggregates_subgroup_column(self): + """ + Test get_aggregates calls with subgroup_column + """ + request = Aggregates.get_aggregates( + EntityType.NVT, + group_column="family", + subgroup_column="solution_type", + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_aggregates_missing_group_column(self): + """ + Test get_aggregates calls with group_column missing + if subgroup_column was given. + """ + with self.assertRaises(RequiredArgument): + Aggregates.get_aggregates( + resource_type=EntityType.NVT, subgroup_column="solution_type" + ) + + with self.assertRaises(RequiredArgument): + Aggregates.get_aggregates( + resource_type=EntityType.NVT, + group_column="", + subgroup_column="solution_type", + ) + + def test_get_aggregates_text_columns(self): + """ + Test get_aggregates calls with text_columns + """ + request = Aggregates.get_aggregates( + EntityType.SCAN_CONFIG, + group_column="uuid", + text_columns=["name", "comment"], + ) + + self.assertEqual( + bytes(request), + b'' + b"name" + b"comment" + b"", + ) + + def test_get_aggregates_invalid_text_columns(self): + """ + Test get_aggregates calls with invalid text_columns + """ + with self.assertRaises(InvalidArgumentType): + Aggregates.get_aggregates( + resource_type=EntityType.ALERT, text_columns=123 + ) + + def test_get_aggregates_mode(self): + """ + Test get_aggregates calls with mode + """ + request = Aggregates.get_aggregates( + EntityType.NVT, group_column="name", mode="word_counts" + ) + + self.assertEqual( + bytes(request), + b'', + ) diff --git a/tests/protocols/gmp/requests/v224/test_alerts.py b/tests/protocols/gmp/requests/v224/test_alerts.py new file mode 100644 index 000000000..5e78afbae --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_alerts.py @@ -0,0 +1,838 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( + AlertCondition, + AlertEvent, + AlertMethod, + Alerts, + ReportFormatType, +) + + +class AlertsTestCase(unittest.TestCase): + def test_create_alerts(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b"", + ) + + def test_create_alert_with_filter_id(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + filter_id="f1", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b'' + b"", + ) + + def test_create_alert_with_comment(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + comment="bar", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b"bar" + b"", + ) + + def test_create_alert_with_condition_data(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + condition_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Alwaysbarfoo" + b"Task run status changed" + b"Email" + b"", + ) + + def test_create_alert_with_event_data(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + event_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Always" + b"Task run status changed" + b"barfoo" + b"" + b"Email" + b"", + ) + + def test_create_alert_with_method_data(self): + request = Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + method_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Emailbarfoo" + b"", + ) + + def test_create_alert_missing_name(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + None, + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_missing_event(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event=None, + method=AlertMethod.EMAIL, + ) + + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event="", + method=AlertMethod.EMAIL, + ) + + def test_create_alert_missing_condition(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition=None, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition="", + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_missing_method(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=None, + ) + + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method="", + ) + + def test_create_alert_invalid_condition(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + "foo", + condition="foo", + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_invalid_event(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event="foo", + method=AlertMethod.EMAIL, + ) + + def test_create_alert_invalid_method(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + "foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method="foo", + ) + + def test_create_alert_invalid_condition_for_secinfo(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.SEVERITY_AT_LEAST, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_invalid_method_for_secinfo(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.HTTP_GET, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.ALEMBA_VFIRE, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.SOURCEFIRE_CONNECTOR, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.START_TASK, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.TIPPINGPOINT_SMS, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.VERINICE_CONNECTOR, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.HTTP_GET, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.ALEMBA_VFIRE, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.SOURCEFIRE_CONNECTOR, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.START_TASK, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.TIPPINGPOINT_SMS, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.VERINICE_CONNECTOR, + ) + + def test_create_alert_missing_method_for_ticket_received(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=None, + ) + + def test_create_alert_missing_condition_for_ticket_received(self): + with self.assertRaises(RequiredArgument): + Alerts.create_alert( + name="foo", + condition=None, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_invalid_method_for_ticket_received(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.HTTP_GET, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.SCP, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.SEND, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.SMB, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.SNMP, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.ALEMBA_VFIRE, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.VERINICE_CONNECTOR, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.TIPPINGPOINT_SMS, + ) + + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.SOURCEFIRE_CONNECTOR, + ) + + def test_create_alert_invalid_condition_for_task_run_status_changed(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.ERROR, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + ) + + def test_create_alert_invalid_condition_for_ticket_received(self): + with self.assertRaises(InvalidArgument): + Alerts.create_alert( + name="foo", + condition=AlertCondition.FILTER_COUNT_AT_LEAST, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.EMAIL, + ) + + def test_modify_alert(self): + request = Alerts.modify_alert( + alert_id="a1", + ) + + self.assertEqual(bytes(request), b'') + + def test_modify_alert_missing_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.modify_alert(alert_id="") + + with self.assertRaises(RequiredArgument): + Alerts.modify_alert(alert_id=None) + + def test_modify_alert_with_comment(self): + request = Alerts.modify_alert( + alert_id="a1", + comment="foo", + ) + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_alert_with_name(self): + request = Alerts.modify_alert( + alert_id="a1", + name="foo", + ) + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_alert_with_filter_id(self): + request = Alerts.modify_alert( + alert_id="a1", + filter_id="f1", + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_alert_with_event_data(self): + request = Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + event_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b'' + b"Always" + b"Email" + b"Task run status changed" + b"barfoo" + b"" + b"", + ) + + def test_modify_alert_with_condition_data(self): + request = Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + condition_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b'' + b"Alwaysbarfoo" + b"Email" + b"Task run status changed" + b"", + ) + + def test_modify_alert_with_method_data(self): + request = Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.EMAIL, + method_data={"foo": "bar"}, + ) + + self.assertEqual( + bytes(request), + b'' + b"Always" + b"Emailbarfoo" + b"Task run status changed" + b"", + ) + + def test_modify_alert_invalid_condition(self): + with self.assertRaises(InvalidArgument): + Alerts.modify_alert( + alert_id="a1", + condition="bar", + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.SCP, + ) + + def test_modify_alert_invalid_event(self): + with self.assertRaises(InvalidArgument): + Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event="lorem", + method=AlertMethod.SCP, + ) + + def test_modify_alert_invalid_method(self): + with self.assertRaises(InvalidArgument): + Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method="ipsum", + ) + + def test_modify_alert_with_event_missing_method(self): + with self.assertRaisesRegex(RequiredArgument, "method is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + condition=AlertCondition.ALWAYS, + ) + + with self.assertRaisesRegex(RequiredArgument, "method is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.NEW_SECINFO_ARRIVED, + condition=AlertCondition.ALWAYS, + ) + + with self.assertRaisesRegex(RequiredArgument, "method is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + condition=AlertCondition.ALWAYS, + ) + + def test_modify_alert_with_event_missing_condition(self): + with self.assertRaisesRegex(RequiredArgument, "condition is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.TASK_RUN_STATUS_CHANGED, + method=AlertMethod.SCP, + ) + + with self.assertRaisesRegex(RequiredArgument, "condition is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.NEW_SECINFO_ARRIVED, + method=AlertMethod.SCP, + ) + + with self.assertRaisesRegex(RequiredArgument, "condition is required"): + Alerts.modify_alert( + alert_id="a1", + event=AlertEvent.UPDATED_SECINFO_ARRIVED, + method=AlertMethod.SCP, + ) + + def test_modify_alert_invalid_condition_for_secinfo(self): + with self.assertRaises(InvalidArgument): + Alerts.modify_alert( + alert_id="a1", + condition="Severity at least", + event="Updated SecInfo arrived", + method="Email", + ) + + def test_modify_alert_invalid_method_for_secinfo(self): + with self.assertRaises(InvalidArgument): + Alerts.modify_alert( + alert_id="a1", + condition="Always", + event="Updated SecInfo arrived", + method="HTTP Get", + ) + + def test_modify_missing_method_for_ticket_received(self): + with self.assertRaises(RequiredArgument): + Alerts.modify_alert( + alert_id="a1", + condition=AlertCondition.ALWAYS, + event=AlertEvent.TICKET_RECEIVED, + method=None, + ) + + def test_modify_missing_condition_for_ticket_received(self): + with self.assertRaises(RequiredArgument): + Alerts.modify_alert( + alert_id="a1", + condition=None, + event=AlertEvent.TICKET_RECEIVED, + method=AlertMethod.EMAIL, + ) + + def test_clone_alert(self): + request = Alerts.clone_alert(alert_id="a1") + + self.assertEqual( + bytes(request), b"a1" + ) + + def test_clone_alert_missing_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.clone_alert(alert_id="") + + with self.assertRaises(RequiredArgument): + Alerts.clone_alert(alert_id=None) + + def test_delete_alert(self): + request = Alerts.delete_alert(alert_id="a1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_alert_ultimate(self): + request = Alerts.delete_alert(alert_id="a1", ultimate=True) + + self.assertEqual( + bytes(request), b'' + ) + + request = Alerts.delete_alert(alert_id="a1", ultimate=False) + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_alert_missing_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.delete_alert(alert_id="") + + with self.assertRaises(RequiredArgument): + Alerts.delete_alert(alert_id=None) + + def test_test_alert(self): + request = Alerts.test_alert(alert_id="a1") + + self.assertEqual(bytes(request), b'') + + def test_test_alert_missing_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.test_alert(alert_id="") + + with self.assertRaises(RequiredArgument): + Alerts.test_alert(alert_id=None) + + def test_trigger_alert(self): + request = Alerts.trigger_alert(alert_id="a1", report_id="r1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_trigger_alert_with_filter_string(self): + request = Alerts.trigger_alert( + alert_id="a1", report_id="r1", filter_string="name=foo" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_trigger_alert_with_filter_id(self): + request = Alerts.trigger_alert( + alert_id="a1", report_id="r1", filter_id="f1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_trigger_alert_with_report_format_id(self): + request = Alerts.trigger_alert( + alert_id="a1", report_id="r1", report_format_id="bar" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_trigger_alert_with_report_format_type(self): + request = Alerts.trigger_alert( + alert_id="a1", + report_id="r1", + report_format_id=ReportFormatType.SVG, + ) + + self.assertEqual( + bytes(request), + ''.encode(encoding="utf-8"), + ) + + def test_trigger_alert_with_delta_report_id(self): + request = Alerts.trigger_alert( + alert_id="a1", report_id="r1", delta_report_id="d1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_trigger_alert_missing_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.trigger_alert(alert_id="", report_id="r1") + + with self.assertRaises(RequiredArgument): + Alerts.trigger_alert(alert_id=None, report_id="r1") + + def test_trigger_alert_missing_report_id(self): + with self.assertRaises(RequiredArgument): + Alerts.trigger_alert(alert_id="a1", report_id="") + + with self.assertRaises(RequiredArgument): + Alerts.trigger_alert(alert_id="a1", report_id=None) + + def test_get_alerts(self): + request = Alerts.get_alerts() + + self.assertEqual(bytes(request), b"") + + def test_get_alerts_with_trash(self): + request = Alerts.get_alerts(trash=True) + + self.assertEqual(bytes(request), b'') + + request = Alerts.get_alerts(trash=False) + + self.assertEqual(bytes(request), b'') + + def test_get_alerts_with_filter_string(self): + request = Alerts.get_alerts(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_get_alerts_with_filter_id(self): + request = Alerts.get_alerts(filter_id="f1") + + self.assertEqual(bytes(request), b'') + + def test_get_alerts_with_tasks(self): + request = Alerts.get_alerts(tasks=True) + + self.assertEqual(bytes(request), b'') + + request = Alerts.get_alerts(tasks=False) + + self.assertEqual(bytes(request), b'') + + def test_get_alert(self): + request = Alerts.get_alert(alert_id="a1") + + self.assertEqual(bytes(request), b'') + + def test_get_alert_with_tasks(self): + request = Alerts.get_alert(alert_id="a1", tasks=True) + + self.assertEqual( + bytes(request), b'' + ) + + request = Alerts.get_alert(alert_id="a1", tasks=False) + + self.assertEqual( + bytes(request), b'' + ) + + def test_get_alert_invalid_alert_id(self): + with self.assertRaises(RequiredArgument): + Alerts.get_alert(alert_id=None) + + with self.assertRaises(RequiredArgument): + Alerts.get_alert(alert_id="") diff --git a/tests/protocols/gmp/requests/v224/test_audits.py b/tests/protocols/gmp/requests/v224/test_audits.py new file mode 100644 index 000000000..20af2c373 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_audits.py @@ -0,0 +1,752 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Audits, HostsOrdering + + +class AuditsTestCase(unittest.TestCase): + def test_create_audit(self): + request = Audits.create_audit( + name="foo", policy_id="c1", target_id="t1", scanner_id="s1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"", + ) + + def test_create_audit_with_comment(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + comment="bar", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"bar" + b"", + ) + + def test_create_audit_with_single_alert(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + alert_ids=["a1"], + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"", + ) + + def test_create_audit_with_multiple_alerts(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + alert_ids=["a1", "a2"], + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b'' + b"", + ) + + def test_create_audit_with_empty_alert_ids(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + alert_ids=[], + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"", + ) + + def test_create_audit_with_alterable(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + alterable=True, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"1" + b"", + ) + + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + alterable=False, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"0" + b"", + ) + + def test_create_audit_with_hosts_ordering(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + hosts_ordering=HostsOrdering.RANDOM, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"random" + b"", + ) + + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + hosts_ordering="random", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"random" + b"", + ) + + def test_create_audit_with_schedule_id(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + schedule_id="s1", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"", + ) + + def test_create_audit_with_schedule_and_schedule_periods(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + schedule_id="s1", + schedule_periods=0, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"0" + b"", + ) + + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + schedule_id="s1", + schedule_periods=5, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"5" + b"", + ) + + def test_create_audit_with_observers(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + observers=["u1", "u2"], + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"u1,u2" + b"", + ) + + def test_create_audit_with_preferences(self): + request = Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + preferences={"foo": "bar", "lorem": "ipsum"}, + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"", + ) + + def test_create_audit_don_t_allow_container_task(self): + with self.assertRaises(InvalidArgument): + Audits.create_audit( + name="foo", + policy_id="c1", + target_id="0", + scanner_id="s1", + observers="", + ) + + # target_id=0 is considered as False + with self.assertRaises(RequiredArgument): + Audits.create_audit( + name="foo", + policy_id="c1", + target_id=0, + scanner_id="s1", + observers="", + ) + + def test_create_audit_missing_name(self): + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "", policy_id="c1", target_id="t1", scanner_id="s1" + ) + + with self.assertRaises(RequiredArgument): + Audits.create_audit( + None, policy_id="c1", target_id="t1", scanner_id="s1" + ) + + def test_create_audit_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id="", target_id="t1", scanner_id="s1" + ) + + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id=None, target_id="t1", scanner_id="s1" + ) + + def test_create_audit_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id="c1", target_id="", scanner_id="s1" + ) + + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id="c1", target_id=None, scanner_id="s1" + ) + + def test_create_audit_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id="c1", target_id="t1", scanner_id="" + ) + + with self.assertRaises(RequiredArgument): + Audits.create_audit( + "foo", policy_id="c1", target_id="t1", scanner_id=None + ) + + def test_create_audit_invalid_hosts_ordering(self): + with self.assertRaises(InvalidArgument): + Audits.create_audit( + "foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + hosts_ordering="invalid", + ) + + def test_create_audit_with_schedule_and_invalid_schedule_periods(self): + with self.assertRaises(InvalidArgument): + Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + schedule_id="s1", + schedule_periods=-1, + ) + + with self.assertRaises(InvalidArgument): + Audits.create_audit( + name="foo", + policy_id="c1", + target_id="t1", + scanner_id="s1", + schedule_id="s1", + schedule_periods="invalid", + ) + + def test_modify_audit(self): + request = Audits.modify_audit("t1") + + self.assertEqual(bytes(request), b'') + + def test_modify_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.modify_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.modify_audit("") + + def test_modify_audit_with_name(self): + request = Audits.modify_audit(audit_id="t1", name="foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_audit_with_policy_id(self): + request = Audits.modify_audit(audit_id="t1", policy_id="c1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_audit_with_target_id(self): + request = Audits.modify_audit(audit_id="t1", target_id="t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_audit_with_scanner_id(self): + request = Audits.modify_audit(audit_id="t1", scanner_id="s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_audit_with_schedule_id(self): + request = Audits.modify_audit(audit_id="t1", schedule_id="s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_audit_with_comment(self): + request = Audits.modify_audit(audit_id="t1", comment="bar") + + self.assertEqual( + bytes(request), + b'' + b"bar" + b"", + ) + + def test_modify_audit_with_alerts_ids(self): + request = Audits.modify_audit(audit_id="t1", alert_ids=["a1", "a2"]) + + self.assertEqual( + bytes(request), + b'' + b'' + b'' + b"", + ) + + def test_modify_audit_with_empty_alert_ids(self): + request = Audits.modify_audit(audit_id="t1", alert_ids=[]) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_audit_with_alterable(self): + request = Audits.modify_audit(audit_id="t1", alterable=True) + + self.assertEqual( + bytes(request), + b'1', + ) + + request = Audits.modify_audit(audit_id="t1", alterable=False) + + self.assertEqual( + bytes(request), + b'0', + ) + + def test_modify_audit_with_hosts_ordering(self): + request = Audits.modify_audit( + audit_id="t1", hosts_ordering=HostsOrdering.RANDOM + ) + self.assertEqual( + bytes(request), + b'' + b"random" + b"", + ) + + request = Audits.modify_audit(audit_id="t1", hosts_ordering="random") + + self.assertEqual( + bytes(request), + b'' + b"random" + b"", + ) + + def test_modify_audit_with_schedule_periods(self): + request = Audits.modify_audit(audit_id="t1", schedule_periods=0) + + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + request = Audits.modify_audit(audit_id="t1", schedule_periods=5) + + self.assertEqual( + bytes(request), + b'' + b"5" + b"", + ) + + def test_modify_audit_with_observers(self): + request = Audits.modify_audit(audit_id="t1", observers=["u1", "u2"]) + + self.assertEqual( + bytes(request), + b'' + b"u1,u2" + b"", + ) + + def test_modify_audit_with_preferences(self): + request = Audits.modify_audit( + audit_id="t1", preferences={"foo": "bar", "lorem": "ipsum"} + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"", + ) + + def test_modify_audit_invalid_hosts_ordering(self): + with self.assertRaises(InvalidArgument): + Audits.modify_audit(audit_id="t1", hosts_ordering="foo") + + def test_modify_audit_invalid_schedule_periods(self): + with self.assertRaises(InvalidArgument): + Audits.modify_audit(audit_id="t1", schedule_periods="foo") + + with self.assertRaises(InvalidArgument): + Audits.modify_audit(audit_id="t1", schedule_periods=-1) + + def test_clone_audit(self): + request = Audits.clone_audit("t1") + + self.assertEqual( + bytes(request), + b"t1", + ) + + def test_clone_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.clone_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.clone_audit("") + + def test_delete_audit(self): + request = Audits.delete_audit("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_audit_with_ultimate(self): + request = Audits.delete_audit("t1", ultimate=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Audits.delete_audit("t1", ultimate=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.delete_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.delete_audit("") + + def test_get_audits(self): + request = Audits.get_audits() + + self.assertEqual(bytes(request), b'') + + def test_get_audits_with_filter_string(self): + request = Audits.get_audits(filter_string="name=foo") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audits_with_filter_id(self): + request = Audits.get_audits(filter_id="f1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audits_with_trash(self): + request = Audits.get_audits(trash=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Audits.get_audits(trash=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audits_with_details(self): + request = Audits.get_audits(details=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Audits.get_audits(details=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audits_with_schedules_only(self): + request = Audits.get_audits(schedules_only=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Audits.get_audits(schedules_only=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audit(self): + request = Audits.get_audit("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.get_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.get_audit("") + + def test_start_audit(self): + request = Audits.start_audit("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_start_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.start_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.start_audit("") + + def test_stop_audit(self): + request = Audits.stop_audit("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_stop_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.stop_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.stop_audit("") + + def test_resume_audit(self): + request = Audits.resume_audit("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_resume_audit_missing_audit_id(self): + with self.assertRaises(RequiredArgument): + Audits.resume_audit(None) + + with self.assertRaises(RequiredArgument): + Audits.resume_audit("") diff --git a/tests/protocols/gmp/requests/v224/test_auth.py b/tests/protocols/gmp/requests/v224/test_auth.py new file mode 100644 index 000000000..e4c660a0d --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_auth.py @@ -0,0 +1,92 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.core import Request +from gvm.protocols.gmp.requests.v224 import Authentication + + +class AuthenticationTestCase(unittest.TestCase): + def test_authenticate(self) -> None: + request = Authentication.authenticate("admin", "admin") + + self.assertIsInstance(request, Request) + self.assertEqual( + bytes(request), + b"admin" + b"admin", + ) + + def test_authenticate_missing_username(self) -> None: + with self.assertRaises(RequiredArgument): + Authentication.authenticate(None, "foo") # type: ignore + + with self.assertRaises(RequiredArgument): + Authentication.authenticate("", "foo") + + def test_authenticate_missing_password(self) -> None: + with self.assertRaises(RequiredArgument): + Authentication.authenticate("bar", None) # type: ignore + + with self.assertRaises(RequiredArgument): + Authentication.authenticate("bar", "") + + def test_describe_auth(self) -> None: + request = Authentication.describe_auth() + + self.assertIsInstance(request, Request) + self.assertEqual(bytes(request), b"") + + def test_modify_auth(self) -> None: + request = Authentication.modify_auth( + "foo", dict([("foo", "bar"), ("lorem", "ipsum")]) + ) + + self.assertIsInstance(request, Request) + self.assertEqual( + bytes(request), + b"" + b'' + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"", + ) + + def test_modify_auth_missing_group_name(self) -> None: + with self.assertRaises(RequiredArgument): + Authentication.modify_auth( + group_name=None, auth_conf_settings={"foo": "bar"} # type: ignore + ) + + with self.assertRaises(RequiredArgument): + Authentication.modify_auth( + group_name="", auth_conf_settings={"foo": "bar"} + ) + + with self.assertRaises(RequiredArgument): + Authentication.modify_auth("", auth_conf_settings={"foo": "bar"}) + + def test_modify_auth_auth_conf_settings(self) -> None: + with self.assertRaises(RequiredArgument): + Authentication.modify_auth( + group_name="foo", auth_conf_settings=None # type: ignore + ) + + with self.assertRaises(RequiredArgument): + Authentication.modify_auth(group_name="foo", auth_conf_settings="") # type: ignore + + with self.assertRaises(RequiredArgument): + Authentication.modify_auth("foo", "") # type: ignore + + with self.assertRaises(RequiredArgument): + Authentication.modify_auth("foo", {}) diff --git a/tests/protocols/gmp/requests/v224/test_cert_bund_advisories.py b/tests/protocols/gmp/requests/v224/test_cert_bund_advisories.py new file mode 100644 index 000000000..053123df4 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_cert_bund_advisories.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import CertBundAdvisories + + +class CertBundAdvisoriesTestCase(unittest.TestCase): + def test_get_cert_bund_advisories(self): + request = CertBundAdvisories.get_cert_bund_advisories() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisories_with_filter_string(self): + request = CertBundAdvisories.get_cert_bund_advisories( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisories_with_filter_id(self): + request = CertBundAdvisories.get_cert_bund_advisories( + filter_id="filter_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisories_with_name(self): + request = CertBundAdvisories.get_cert_bund_advisories(name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisories_with_details(self): + request = CertBundAdvisories.get_cert_bund_advisories(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = CertBundAdvisories.get_cert_bund_advisories(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisory(self): + request = CertBundAdvisories.get_cert_bund_advisory("cert_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cert_bund_advisory_missing_cert_id(self): + with self.assertRaises(RequiredArgument): + CertBundAdvisories.get_cert_bund_advisory(None) + + with self.assertRaises(RequiredArgument): + CertBundAdvisories.get_cert_bund_advisory("") diff --git a/tests/protocols/gmp/requests/v224/test_cpes.py b/tests/protocols/gmp/requests/v224/test_cpes.py new file mode 100644 index 000000000..7228a3fcd --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_cpes.py @@ -0,0 +1,65 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Cpes + + +class CpesTestCase(unittest.TestCase): + def test_get_cpes(self): + request = Cpes.get_cpes() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpes_with_filter_string(self): + request = Cpes.get_cpes(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpes_with_filter_id(self): + request = Cpes.get_cpes(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpes_with_name(self): + request = Cpes.get_cpes(name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpes_with_details(self): + request = Cpes.get_cpes(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Cpes.get_cpes(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpe(self): + request = Cpes.get_cpe("cpe_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cpe_missing_cpe_id(self): + with self.assertRaises(RequiredArgument): + Cpes.get_cpe(None) + + with self.assertRaises(RequiredArgument): + Cpes.get_cpe("") diff --git a/tests/protocols/gmp/requests/v224/test_credentials.py b/tests/protocols/gmp/requests/v224/test_credentials.py new file mode 100644 index 000000000..b5903a87c --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_credentials.py @@ -0,0 +1,818 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( + CredentialFormat, + Credentials, + CredentialType, + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, +) + + +class CredentialsTestCase(unittest.TestCase): + def test_clone_credential_missing_credential_id(self): + with self.assertRaises(RequiredArgument): + Credentials.clone_credential(None) + + with self.assertRaises(RequiredArgument): + Credentials.clone_credential("") + + def test_clone_credential(self): + request = Credentials.clone_credential("a1") + self.assertEqual( + bytes(request), + b"a1", + ) + + def test_create_credential_missing_name(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + None, CredentialType.PASSWORD_ONLY, password="password" + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "", CredentialType.PASSWORD_ONLY, password="password" + ) + + def test_create_credential_missing_credential_type(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential("name", None) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential("name", "") + + def test_create_credential_invalid_credential_type(self): + with self.assertRaises(InvalidArgument): + Credentials.create_credential("name", "invalid") + + def test_create_credential_username_password(self): + request = Credentials.create_credential( + "name", + CredentialType.USERNAME_PASSWORD, + login="username", + password="password", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"up" + b"username" + b"password" + b"", + ) + + def test_create_username_password_credential_with_allow_insecure(self): + request = Credentials.create_credential( + "name", + CredentialType.USERNAME_PASSWORD, + login="username", + password="password", + allow_insecure=True, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"up" + b"1" + b"username" + b"password" + b"", + ) + + def test_create_credential_username_password_with_comment(self): + request = Credentials.create_credential( + "name", + CredentialType.USERNAME_PASSWORD, + login="username", + password="password", + comment="comment", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"up" + b"comment" + b"username" + b"password" + b"", + ) + + def test_create_credential_username_password_missing_login(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.USERNAME_PASSWORD, password="password" + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.USERNAME_PASSWORD, + login="", + password="password", + ) + + def test_create_credential_client_certificate(self): + request = Credentials.create_credential( + "name", + CredentialType.CLIENT_CERTIFICATE, + certificate="certificate", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"cc" + b"certificate" + b"", + ) + + def test_create_credential_client_certificate_with_private_key(self): + request = Credentials.create_credential( + "name", + CredentialType.CLIENT_CERTIFICATE, + certificate="certificate", + private_key="private_key", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"cc" + b"certificate" + b"" + b"private_key" + b"" + b"", + ) + + def test_create_credential_client_certificate_missing_certificate(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.CLIENT_CERTIFICATE + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.CLIENT_CERTIFICATE, certificate="" + ) + + def test_create_credential_username_ssh_key(self): + request = Credentials.create_credential( + "name", + CredentialType.USERNAME_SSH_KEY, + login="username", + private_key="private", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"usk" + b"username" + b"" + b"private" + b"" + b"", + ) + + def test_create_credential_username_ssh_key_with_passphrase(self): + request = Credentials.create_credential( + "name", + CredentialType.USERNAME_SSH_KEY, + login="username", + private_key="private", + key_phrase="passphrase", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"usk" + b"username" + b"" + b"private" + b"passphrase" + b"" + b"", + ) + + def test_create_credential_username_ssh_key_missing_private_key(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.USERNAME_SSH_KEY, login="username" + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.USERNAME_SSH_KEY, + login="username", + private_key="", + ) + + def test_create_credential_username_ssh_key_missing_login(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.USERNAME_SSH_KEY, private_key="private" + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.USERNAME_SSH_KEY, + login="", + private_key="private", + ) + + def test_create_credential_snmp_with_auth_algorithm_md5(self): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="username", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"md5" + b"", + ) + + def test_create_credential_snmp_with_auth_algorithm_sha1(self): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.SHA1, + login="username", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"sha1" + b"", + ) + + def test_create_credential_snmp_missing_auth_algorithm(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.SNMP, login="username" + ) + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SNMP, + login="username", + auth_algorithm=None, + ) + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SNMP, + login="username", + auth_algorithm="", + ) + + def test_create_credential_snmp_missing_login(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="", + ) + + def test_create_credential_snmp_with_community(self): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="username", + community="community", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"md5" + b"community" + b"", + ) + + def test_create_credential_snmp_with_password(self): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="username", + password="password", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"password" + b"md5" + b"", + ) + + def test_create_credential_snmp_with_privacy_algorithm(self): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="username", + privacy_algorithm=SnmpPrivacyAlgorithm.DES, + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"md5" + b"" + b"des" + b"" + b"", + ) + + def test_create_credential_snmp_with_privacy_algorithm_and_privacy_password( + self, + ): + request = Credentials.create_credential( + "name", + CredentialType.SNMP, + auth_algorithm=SnmpAuthAlgorithm.MD5, + login="username", + privacy_algorithm=SnmpPrivacyAlgorithm.DES, + privacy_password="password", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"snmp" + b"username" + b"md5" + b"" + b"des" + b"password" + b"" + b"", + ) + + def test_create_credential_pgp(self): + request = Credentials.create_credential( + "name", + CredentialType.PGP_ENCRYPTION_KEY, + public_key="public_key", + ) + + self.assertEqual( + bytes(request), + b"" + b"name" + b"pgp" + b"" + b"public_key" + b"" + b"", + ) + + def test_create_credential_pgp_missing_key(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.PGP_ENCRYPTION_KEY + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.PGP_ENCRYPTION_KEY, public_key=None + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.PGP_ENCRYPTION_KEY, public_key="" + ) + + def test_create_credential_password_only(self): + request = Credentials.create_credential( + "name", + CredentialType.PASSWORD_ONLY, + password="password", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"pw" + b"password" + b"", + ) + + def test_create_credential_password_only_missing_password(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential("name", CredentialType.PASSWORD_ONLY) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.PASSWORD_ONLY, password=None + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", CredentialType.PASSWORD_ONLY, password="" + ) + + def test_create_credential_smime(self): + request = Credentials.create_credential( + "name", + CredentialType.SMIME_CERTIFICATE, + certificate="certificate", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"smime" + b"certificate" + b"", + ) + + def test_create_credential_smime_missing_certificate(self): + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SMIME_CERTIFICATE, + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SMIME_CERTIFICATE, + certificate=None, + ) + + with self.assertRaises(RequiredArgument): + Credentials.create_credential( + "name", + CredentialType.SMIME_CERTIFICATE, + certificate="", + ) + + def test_delete_alert(self): + request = Credentials.delete_credential("a1") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_alert_with_ultimate(self): + request = Credentials.delete_credential("a1", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.delete_credential("a1", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_alert_missing_credential_id(self): + with self.assertRaises(RequiredArgument): + Credentials.delete_credential(None) + + with self.assertRaises(RequiredArgument): + Credentials.delete_credential("") + + def test_get_credentials(self): + request = Credentials.get_credentials() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_credentials_with_filter_string(self): + request = Credentials.get_credentials(filter_string="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credentials_with_scanners(self): + request = Credentials.get_credentials(scanners=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credentials_with_trash(self): + request = Credentials.get_credentials(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credentials_with_targets(self): + request = Credentials.get_credentials(targets=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credential(self): + request = Credentials.get_credential("a1") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credential_with_scanners(self): + request = Credentials.get_credential("a1", scanners=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credential_with_targets(self): + request = Credentials.get_credential("a1", targets=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credential_with_credential_format(self): + request = Credentials.get_credential("a1", credential_format="key") + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.get_credential( + "a1", credential_format=CredentialFormat.KEY + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.get_credential( + "a1", credential_format=CredentialFormat.EXE + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.get_credential( + "a1", credential_format=CredentialFormat.DEB + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.get_credential( + "a1", credential_format=CredentialFormat.PEM + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = Credentials.get_credential( + "a1", credential_format=CredentialFormat.RPM + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_credential_missing_credential_id(self): + with self.assertRaises(RequiredArgument): + Credentials.get_credential(None) + + with self.assertRaises(RequiredArgument): + Credentials.get_credential("") + + def test_modify_credential_with_name(self): + request = Credentials.modify_credential("a1", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_credential_with_comment(self): + request = Credentials.modify_credential("a1", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_credential_with_allow_insecure(self): + request = Credentials.modify_credential("a1", allow_insecure=True) + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + request = Credentials.modify_credential("a1", allow_insecure=False) + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_credential_with_certificate(self): + request = Credentials.modify_credential("a1", certificate="certificate") + self.assertEqual( + bytes(request), + b'' + b"certificate" + b"", + ) + + def test_modify_credential_with_key_phrase_and_private_key(self): + request = Credentials.modify_credential( + "a1", key_phrase="passphrase", private_key="private" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"passphrase" + b"private" + b"" + b"", + ) + + def test_modify_credential_missing_key_phrase_or_private_key(self): + with self.assertRaises(RequiredArgument): + Credentials.modify_credential("a1", key_phrase="passphrase") + + with self.assertRaises(RequiredArgument): + Credentials.modify_credential("a1", private_key="private") + + def test_modify_credential_with_login(self): + request = Credentials.modify_credential("a1", login="username") + self.assertEqual( + bytes(request), + b'' + b"username" + b"", + ) + + def test_modify_credential_with_password(self): + request = Credentials.modify_credential("a1", password="password") + self.assertEqual( + bytes(request), + b'' + b"password" + b"", + ) + + def test_modify_credential_with_auth_algorithm(self): + request = Credentials.modify_credential( + "a1", auth_algorithm=SnmpAuthAlgorithm.MD5 + ) + self.assertEqual( + bytes(request), + b'' + b"md5" + b"", + ) + + request = Credentials.modify_credential("a1", auth_algorithm="md5") + self.assertEqual( + bytes(request), + b'' + b"md5" + b"", + ) + + request = Credentials.modify_credential( + "a1", auth_algorithm=SnmpAuthAlgorithm.SHA1 + ) + self.assertEqual( + bytes(request), + b'' + b"sha1" + b"", + ) + + def test_modify_credential_with_community(self): + request = Credentials.modify_credential("a1", community="community") + self.assertEqual( + bytes(request), + b'' + b"community" + b"", + ) + + def test_modify_credential_with_privacy_algorithm(self): + request = Credentials.modify_credential( + "a1", privacy_algorithm=SnmpPrivacyAlgorithm.DES + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"des" + b"" + b"", + ) + + request = Credentials.modify_credential("a1", privacy_algorithm="des") + self.assertEqual( + bytes(request), + b'' + b"" + b"des" + b"" + b"", + ) + + request = Credentials.modify_credential( + "a1", privacy_algorithm=SnmpPrivacyAlgorithm.AES + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"aes" + b"" + b"", + ) + + def test_modify_credential_with_privacy_password(self): + request = Credentials.modify_credential( + "a1", privacy_password="password" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"password" + b"" + b"", + ) + + def test_modify_credential_with_public_key(self): + request = Credentials.modify_credential("a1", public_key="public_key") + self.assertEqual( + bytes(request), + b'' + b"" + b"public_key" + b"" + b"", + ) + + def test_modify_credential_missing_credential_id(self): + with self.assertRaises(RequiredArgument): + Credentials.modify_credential(None) + + with self.assertRaises(RequiredArgument): + Credentials.modify_credential("") diff --git a/tests/protocols/gmp/requests/v224/test_cves.py b/tests/protocols/gmp/requests/v224/test_cves.py new file mode 100644 index 000000000..6e57eed73 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_cves.py @@ -0,0 +1,65 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Cves + + +class CvesTestCase(unittest.TestCase): + def test_get_cves(self): + request = Cves.get_cves() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cves_with_filter_string(self): + request = Cves.get_cves(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cves_with_filter_id(self): + request = Cves.get_cves(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cves_with_name(self): + request = Cves.get_cves(name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cves_with_details(self): + request = Cves.get_cves(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Cves.get_cves(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cve(self): + request = Cves.get_cve("cve_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_cve_missing_cve_id(self): + with self.assertRaises(RequiredArgument): + Cves.get_cve(None) + + with self.assertRaises(RequiredArgument): + Cves.get_cve("") diff --git a/tests/protocols/gmp/requests/v224/test_dfn_cert_advisories.py b/tests/protocols/gmp/requests/v224/test_dfn_cert_advisories.py new file mode 100644 index 000000000..a36d82649 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_dfn_cert_advisories.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import DfnCertAdvisories + + +class DfnCertAdvisoriesTestCase(unittest.TestCase): + def test_get_dfn_cert_advisories(self): + request = DfnCertAdvisories.get_dfn_cert_advisories() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisories_with_filter_string(self): + request = DfnCertAdvisories.get_dfn_cert_advisories( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisories_with_filter_id(self): + request = DfnCertAdvisories.get_dfn_cert_advisories( + filter_id="filter_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisories_with_name(self): + request = DfnCertAdvisories.get_dfn_cert_advisories(name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisories_with_details(self): + request = DfnCertAdvisories.get_dfn_cert_advisories(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = DfnCertAdvisories.get_dfn_cert_advisories(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisory(self): + request = DfnCertAdvisories.get_dfn_cert_advisory("cert_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_dfn_cert_advisory_missing_cert_id(self): + with self.assertRaises(RequiredArgument): + DfnCertAdvisories.get_dfn_cert_advisory(None) + + with self.assertRaises(RequiredArgument): + DfnCertAdvisories.get_dfn_cert_advisory("") diff --git a/tests/protocols/gmp/requests/v224/test_feed.py b/tests/protocols/gmp/requests/v224/test_feed.py new file mode 100644 index 000000000..77cdb5bad --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_feed.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Feed, FeedType + + +class FeedTestCase(unittest.TestCase): + def test_get_feed(self) -> None: + """ + Test basic get_feed calls with only resource_type except special + cases for audit, policy, scan_config and task. + """ + request = Feed.get_feed(FeedType.NVT) + + self.assertEqual(bytes(request), b'') + + request = Feed.get_feed(FeedType.CERT) + + self.assertEqual(bytes(request), b'') + + request = Feed.get_feed(FeedType.SCAP) + + self.assertEqual(bytes(request), b'') + + request = Feed.get_feed(FeedType.GVMD_DATA) + + self.assertEqual(bytes(request), b'') + + def test_get_feed_missing_type(self): + """ + Test get_feed calls with missing resource_type + """ + with self.assertRaises(RequiredArgument): + Feed.get_feed(feed_type=None) + + with self.assertRaises(RequiredArgument): + Feed.get_feed(feed_type="") + + with self.assertRaises(RequiredArgument): + Feed.get_feed("") + + def test_get_feed_invalid_type(self): + """ + Test get_feed calls with invalid resource_type + """ + with self.assertRaises(InvalidArgument): + Feed.get_feed("foo") diff --git a/tests/protocols/gmp/requests/v224/test_filters.py b/tests/protocols/gmp/requests/v224/test_filters.py new file mode 100644 index 000000000..f2203372e --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_filters.py @@ -0,0 +1,247 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Filters, FilterType + + +class FilterTestsCase(unittest.TestCase): + def test_clone_filter(self): + request = Filters.clone_filter("filter_id") + self.assertEqual( + bytes(request), + b"filter_id", + ) + + def test_clone_filter_missing_filter_id(self): + with self.assertRaises(RequiredArgument): + Filters.clone_filter(None) + + with self.assertRaises(RequiredArgument): + Filters.clone_filter("") + + def test_create_filter(self): + request = Filters.create_filter("filter_name") + self.assertEqual( + bytes(request), + b"filter_name", + ) + + def test_create_filter_with_comment(self): + request = Filters.create_filter("filter_name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"filter_name" + b"comment" + b"", + ) + + def test_create_filter_with_term(self): + request = Filters.create_filter("filter_name", term="term") + self.assertEqual( + bytes(request), + b"" + b"filter_name" + b"term" + b"", + ) + + def test_create_filter_with_filter_type(self): + request = Filters.create_filter( + "filter_name", filter_type=FilterType.ALERT + ) + self.assertEqual( + bytes(request), + b"" + b"filter_name" + b"alert" + b"", + ) + + request = Filters.create_filter( + "filter_name", + filter_type="alert", + ) + self.assertEqual( + bytes(request), + b"" + b"filter_name" + b"alert" + b"", + ) + + def test_create_filter_invalid_filter_type(self): + with self.assertRaises(InvalidArgument): + Filters.create_filter("filter_name", filter_type="invalid") + + def test_create_filter_missing_name(self): + with self.assertRaises(RequiredArgument): + Filters.create_filter(None) + + with self.assertRaises(RequiredArgument): + Filters.create_filter("") + + def test_delete_filter(self): + request = Filters.delete_filter("filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_filter_with_ultimate(self): + request = Filters.delete_filter("filter_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Filters.delete_filter("filter_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_filter_missing_filter_id(self): + with self.assertRaises(RequiredArgument): + Filters.delete_filter(None) + + with self.assertRaises(RequiredArgument): + Filters.delete_filter("") + + def test_get_filters(self): + request = Filters.get_filters() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_filters_with_filter_string(self): + request = Filters.get_filters(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filters_with_filter_id(self): + request = Filters.get_filters(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filters_with_trash(self): + request = Filters.get_filters(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Filters.get_filters(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filters_with_alerts(self): + request = Filters.get_filters(alerts=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Filters.get_filters(alerts=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filter(self): + request = Filters.get_filter("filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filter_with_alerts(self): + request = Filters.get_filter("filter_id", alerts=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Filters.get_filter("filter_id", alerts=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_filter_missing_filter_id(self): + with self.assertRaises(RequiredArgument): + Filters.get_filter(None) + + with self.assertRaises(RequiredArgument): + Filters.get_filter("") + + def test_modify_filter(self): + request = Filters.modify_filter("filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_filter_with_comment(self): + request = Filters.modify_filter("filter_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_filter_with_name(self): + request = Filters.modify_filter("filter_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_filter_with_term(self): + request = Filters.modify_filter("filter_id", term="term") + self.assertEqual( + bytes(request), + b'' + b"term" + b"", + ) + + def test_modify_filter_with_type(self): + request = Filters.modify_filter( + "filter_id", filter_type=FilterType.ALERT + ) + self.assertEqual( + bytes(request), + b'' + b"alert" + b"", + ) + + request = Filters.modify_filter("filter_id", filter_type="alert") + self.assertEqual( + bytes(request), + b'' + b"alert" + b"", + ) + + def test_modify_filter_missing_filter_id(self): + with self.assertRaises(RequiredArgument): + Filters.modify_filter(None) + + with self.assertRaises(RequiredArgument): + Filters.modify_filter("") diff --git a/tests/protocols/gmp/requests/v224/test_groups.py b/tests/protocols/gmp/requests/v224/test_groups.py new file mode 100644 index 000000000..e5f5fc9be --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_groups.py @@ -0,0 +1,190 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Groups + + +class GroupsTestCase(unittest.TestCase): + def test_clone_group(self): + request = Groups.clone_group("group_id") + self.assertEqual( + bytes(request), + b"group_id", + ) + + def test_clone_group_missing_group_id(self): + with self.assertRaises(RequiredArgument): + Groups.clone_group(None) + + with self.assertRaises(RequiredArgument): + Groups.clone_group("") + + def test_create_group(self): + request = Groups.create_group("group_name") + self.assertEqual( + bytes(request), + b"group_name", + ) + + def test_create_group_with_comment(self): + request = Groups.create_group("group_name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"group_name" + b"comment" + b"", + ) + + def test_create_group_with_special(self): + request = Groups.create_group("group_name", special=True) + self.assertEqual( + bytes(request), + b"" + b"group_name" + b"" + b"", + ) + + request = Groups.create_group("group_name", special=False) + self.assertEqual( + bytes(request), + b"group_name", + ) + + def test_create_group_with_users(self): + request = Groups.create_group("group_name", users=["user1", "user2"]) + self.assertEqual( + bytes(request), + b"" + b"group_name" + b"user1,user2" + b"", + ) + + def test_create_group_missing_name(self): + with self.assertRaises(RequiredArgument): + Groups.create_group(None) + + with self.assertRaises(RequiredArgument): + Groups.create_group("") + + def test_delete_group(self): + request = Groups.delete_group("group_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_group_with_ultimate(self): + request = Groups.delete_group("group_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Groups.delete_group("group_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_group_missing_group_id(self): + with self.assertRaises(RequiredArgument): + Groups.delete_group(None) + + with self.assertRaises(RequiredArgument): + Groups.delete_group("") + + def test_get_groups(self): + request = Groups.get_groups() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_groups_with_filter_string(self): + request = Groups.get_groups(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_groups_with_filter_id(self): + request = Groups.get_groups(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_groups_with_trash(self): + request = Groups.get_groups(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Groups.get_groups(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_group(self): + request = Groups.get_group("group_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_group_missing_group_id(self): + with self.assertRaises(RequiredArgument): + Groups.get_group(None) + + with self.assertRaises(RequiredArgument): + Groups.get_group("") + + def test_modify_group(self): + request = Groups.modify_group("group_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_group_with_comment(self): + request = Groups.modify_group("group_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_group_with_name(self): + request = Groups.modify_group("group_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_group_with_users(self): + request = Groups.modify_group("group_id", users=["user1", "user2"]) + self.assertEqual( + bytes(request), + b'' + b"user1,user2" + b"", + ) + + def test_modify_group_missing_group_id(self): + with self.assertRaises(RequiredArgument): + Groups.modify_group(None) + + with self.assertRaises(RequiredArgument): + Groups.modify_group("") diff --git a/tests/protocols/gmp/requests/v224/test_help.py b/tests/protocols/gmp/requests/v224/test_help.py new file mode 100644 index 000000000..6d42dacdb --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_help.py @@ -0,0 +1,29 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.v224 import Help, HelpFormat + + +class HelpTestCase(unittest.TestCase): + def test_help(self): + request = Help.help() + + self.assertEqual(bytes(request), b'') + + def test_help_type_brief(self): + request = Help.help(brief=True) + + self.assertEqual(bytes(request), b'') + + def test_invalid_help_format(self): + with self.assertRaises(InvalidArgument): + Help.help(help_format="foo") + + def test_html_format(self): + request = Help.help(help_format=HelpFormat.HTML) + + self.assertEqual(bytes(request), b'') diff --git a/tests/protocols/gmp/requests/v224/test_hosts.py b/tests/protocols/gmp/requests/v224/test_hosts.py new file mode 100644 index 000000000..9aee78914 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_hosts.py @@ -0,0 +1,138 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Hosts + + +class HostsTestCase(unittest.TestCase): + def test_create_host(self): + request = Hosts.create_host("host_name") + self.assertEqual( + bytes(request), + b"" + b"host" + b"host_name" + b"", + ) + + def test_create_host_with_comment(self): + request = Hosts.create_host("host_name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"host" + b"host_name" + b"comment" + b"", + ) + + def test_create_host_missing_name(self): + with self.assertRaises(RequiredArgument): + Hosts.create_host(None) + + with self.assertRaises(RequiredArgument): + Hosts.create_host("") + + def test_delete_host(self): + request = Hosts.delete_host("host_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_host_missing_host_id(self): + with self.assertRaises(RequiredArgument): + Hosts.delete_host(None) + + with self.assertRaises(RequiredArgument): + Hosts.delete_host("") + + def test_get_hosts(self): + request = Hosts.get_hosts() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_hosts_with_filter_string(self): + request = Hosts.get_hosts(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_hosts_with_filter_id(self): + request = Hosts.get_hosts(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_hosts_with_details(self): + request = Hosts.get_hosts(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Hosts.get_hosts(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_host(self): + request = Hosts.get_host("host_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_host_with_details(self): + request = Hosts.get_host("host_id", details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Hosts.get_host("host_id", details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_host_missing_host_id(self): + with self.assertRaises(RequiredArgument): + Hosts.get_host(None) + + with self.assertRaises(RequiredArgument): + Hosts.get_host("") + + def test_modify_host(self): + request = Hosts.modify_host("host_id") + self.assertEqual( + bytes(request), + b'' + b"" + b"", + ) + + def test_modify_host_with_comment(self): + request = Hosts.modify_host("host_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_host_missing_host_id(self): + with self.assertRaises(RequiredArgument): + Hosts.modify_host(None) + + with self.assertRaises(RequiredArgument): + Hosts.modify_host("") diff --git a/tests/protocols/gmp/requests/v224/test_notes.py b/tests/protocols/gmp/requests/v224/test_notes.py new file mode 100644 index 000000000..7cba03b66 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_notes.py @@ -0,0 +1,365 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest +from decimal import Decimal + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Notes + + +class NotesTestCase(unittest.TestCase): + def test_create_note(self): + request = Notes.create_note("foo", nvt_oid="oid1") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"", + ) + + def test_create_note_missing_text(self): + with self.assertRaises(RequiredArgument): + Notes.create_note(None, "od1") + + with self.assertRaises(RequiredArgument): + Notes.create_note("", "oid1") + + def test_create_note_missing_nvt_oid(self): + with self.assertRaises(RequiredArgument): + Notes.create_note("foo", None) + + with self.assertRaises(RequiredArgument): + Notes.create_note("foo", "") + + def test_create_note_with_hosts(self): + request = Notes.create_note("foo", nvt_oid="oid1", hosts=[]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"", + ) + + request = Notes.create_note("foo", nvt_oid="oid1", hosts=["h1", "h2"]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"h1,h2" + b"", + ) + + def test_create_note_with_port(self): + request = Notes.create_note("foo", nvt_oid="oid1", port="666/tcp") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"666/tcp" + b"", + ) + + def test_create_note_with_result_id(self): + request = Notes.create_note("foo", nvt_oid="oid1", result_id="r1") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b'' + b"", + ) + + def test_create_note_with_task_id(self): + request = Notes.create_note("foo", nvt_oid="oid1", task_id="t1") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b'' + b"", + ) + + def test_create_note_with_severity(self): + request = Notes.create_note("foo", nvt_oid="oid1", severity="5.5") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + def test_create_note_with_days_active(self): + request = Notes.create_note("foo", nvt_oid="oid1", days_active=5) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5" + b"", + ) + + def test_create_note_with_invalid_port(self): + with self.assertRaises(InvalidArgument): + Notes.create_note("foo", nvt_oid="oid1", port="666") + + with self.assertRaises(InvalidArgument): + Notes.create_note("foo", nvt_oid="oid1", port="666/") + + with self.assertRaises(InvalidArgument): + Notes.create_note("foo", nvt_oid="oid1", port="udp/666") + + def test_modify_note(self): + request = Notes.modify_note("n1", "foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_note_missing_note_id(self): + with self.assertRaises(RequiredArgument): + Notes.modify_note(None, "foo") + + with self.assertRaises(RequiredArgument): + Notes.modify_note("", "foo") + + def test_modify_note_missing_text(self): + with self.assertRaises(RequiredArgument): + Notes.modify_note("n1", None) + + with self.assertRaises(RequiredArgument): + Notes.modify_note("n1", "") + + def test_modify_note_with_days_active(self): + request = Notes.modify_note("n1", "foo", days_active=0) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"0" + b"", + ) + + request = Notes.modify_note("n1", "foo", days_active=-1) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"-1" + b"", + ) + + request = Notes.modify_note("n1", "foo", days_active=600) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"600" + b"", + ) + + def test_modify_note_with_port(self): + request = Notes.modify_note("n1", "foo", port="123/tcp") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"123/tcp" + b"", + ) + + def test_modify_note_with_hosts(self): + request = Notes.modify_note("n1", "foo", hosts=["h1"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"h1" + b"", + ) + + request = Notes.modify_note("n1", "foo", hosts=["h1", "h2"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"h1,h2" + b"", + ) + + def test_modify_note_with_result_id(self): + request = Notes.modify_note("n1", "foo", result_id="r1") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b'' + b"", + ) + + def test_modify_note_with_task_id(self): + request = Notes.modify_note("n1", "foo", task_id="t1") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b'' + b"", + ) + + def test_modify_note_with_severity(self): + request = Notes.modify_note("n1", "foo", severity="5.5") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Notes.modify_note("n1", "foo", severity=5.5) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Notes.modify_note("n1", "foo", severity=Decimal(5.5)) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + def test_modify_note_with_invalid_port(self): + with self.assertRaises(InvalidArgument): + Notes.modify_note("n1", "foo", port="666") + + with self.assertRaises(InvalidArgument): + Notes.modify_note("n1", "foo", port="666/") + + with self.assertRaises(InvalidArgument): + Notes.modify_note("n1", "foo", port="udp/666") + + def test_clone_note(self): + request = Notes.clone_note("n1") + + self.assertEqual( + bytes(request), + b"n1", + ) + + def test_clone_note_missing_note_id(self): + with self.assertRaises(RequiredArgument): + Notes.clone_note(None) + + with self.assertRaises(RequiredArgument): + Notes.clone_note("") + + def test_delete_note(self): + request = Notes.delete_note("n1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_note_ultimate(self): + request = Notes.delete_note("n1", ultimate=True) + + self.assertEqual( + bytes(request), b'' + ) + + request = Notes.delete_note("n1", ultimate=False) + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_note_missing_note_id(self): + with self.assertRaises(RequiredArgument): + Notes.delete_note(None) + + with self.assertRaises(RequiredArgument): + Notes.delete_note("") + + def test_get_notes(self): + request = Notes.get_notes() + + self.assertEqual(bytes(request), b"") + + def test_get_notes_with_filter_string(self): + request = Notes.get_notes(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_get_notes_with_filter_id(self): + request = Notes.get_notes(filter_id="f1") + + self.assertEqual(bytes(request), b'') + + def test_get_notes_with_details(self): + request = Notes.get_notes(details=True) + + self.assertEqual(bytes(request), b'') + + request = Notes.get_notes(details=False) + + self.assertEqual(bytes(request), b'') + + def test_get_notes_with_result(self): + request = Notes.get_notes(result=True) + + self.assertEqual(bytes(request), b'') + + request = Notes.get_notes(result=False) + + self.assertEqual(bytes(request), b'') + + def test_get_note(self): + request = Notes.get_note("n1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_get_note_missing_note_id(self): + with self.assertRaises(RequiredArgument): + Notes.get_note(None) + + with self.assertRaises(RequiredArgument): + Notes.get_note("") diff --git a/tests/protocols/gmp/requests/v224/test_nvts.py b/tests/protocols/gmp/requests/v224/test_nvts.py new file mode 100644 index 000000000..48045a5bc --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_nvts.py @@ -0,0 +1,267 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Nvts + + +class NvtsTestCase(unittest.TestCase): + def test_get_nvt_families(self): + request = Nvts.get_nvt_families() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_nvt_families_with_sort_order(self): + request = Nvts.get_nvt_families(sort_order="sort_order") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts(self): + request = Nvts.get_scan_config_nvts() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_scan_config_nvts_with_details(self): + request = Nvts.get_scan_config_nvts(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_scan_config_nvts(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_preferences(self): + request = Nvts.get_scan_config_nvts(preferences=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_scan_config_nvts(preferences=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_preference_count(self): + request = Nvts.get_scan_config_nvts(preference_count=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_scan_config_nvts(preference_count=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_timeout(self): + request = Nvts.get_scan_config_nvts(timeout=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_scan_config_nvts(timeout=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_config_id(self): + request = Nvts.get_scan_config_nvts(config_id="config_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_preferences_config_id(self): + request = Nvts.get_scan_config_nvts( + preferences_config_id="preferences_config_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_family(self): + request = Nvts.get_scan_config_nvts(family="family") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_sort_order(self): + request = Nvts.get_scan_config_nvts(sort_order="sort_order") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvts_with_sort_field(self): + request = Nvts.get_scan_config_nvts(sort_field="sort_field") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvt(self): + request = Nvts.get_scan_config_nvt("nvt_oid") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_nvt_missing_nvt_oid(self): + with self.assertRaises(RequiredArgument): + Nvts.get_scan_config_nvt(None) + + with self.assertRaises(RequiredArgument): + Nvts.get_scan_config_nvt("") + + def test_get_nvts(self): + request = Nvts.get_nvts() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvts_with_name(self): + request = Nvts.get_nvts(name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvts_with_details(self): + request = Nvts.get_nvts(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_nvts(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvts_with_extended(self): + request = Nvts.get_nvts(extended=True) + self.assertEqual( + bytes(request), + b"", + ) + + request = Nvts.get_nvts(extended=False) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_nvts( + extended=False, + details=True, + preferences=True, # gets ignored + preference_count=True, # gets ignored + timeout=True, # gets ignored + config_id="config_id", # gets ignored + preferences_config_id="preferences_config_id", # gets ignored + family="family", # gets ignored + sort_order="sort_order", # gets ignored + sort_field="sort_field", # gets ignored + ) + self.assertEqual(bytes(request), b'') + + request = Nvts.get_nvts( + extended=True, + details=True, + preferences=True, + preference_count=True, + timeout=True, + config_id="config_id", + preferences_config_id="preferences_config_id", + family="family", + sort_order="sort_order", + sort_field="sort_field", + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvt(self): + request = Nvts.get_nvt("nvt_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvt_with_extended(self): + request = Nvts.get_nvt("nvt_id", extended=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Nvts.get_nvt("nvt_id", extended=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvts_missing_nvt_id(self): + with self.assertRaises(RequiredArgument): + Nvts.get_nvt(None) + + with self.assertRaises(RequiredArgument): + Nvts.get_nvt("") + + def test_get_nvt_preferences(self): + request = Nvts.get_nvt_preferences() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_nvt_preferences_with_nvt_oid(self): + request = Nvts.get_nvt_preferences(nvt_oid="nvt_oid") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvt_preference(self): + request = Nvts.get_nvt_preference("preference") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvt_preference_with_nvt_oid(self): + request = Nvts.get_nvt_preference("preference", nvt_oid="nvt_oid") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_nvt_preference_missing_name(self): + with self.assertRaises(RequiredArgument): + Nvts.get_nvt_preference(None) + + with self.assertRaises(RequiredArgument): + Nvts.get_nvt_preference("") diff --git a/tests/protocols/gmp/requests/v224/test_operating_systems.py b/tests/protocols/gmp/requests/v224/test_operating_systems.py new file mode 100644 index 000000000..3db469b06 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_operating_systems.py @@ -0,0 +1,114 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import OperatingSystems + + +class OperatingSystemsTestCase(unittest.TestCase): + def test_delete_operating_system(self): + request = OperatingSystems.delete_operating_system( + "operating_system_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_operating_system_missing_operating_system_id(self): + with self.assertRaises(RequiredArgument): + OperatingSystems.delete_operating_system(None) + + with self.assertRaises(RequiredArgument): + OperatingSystems.delete_operating_system("") + + def test_get_operating_systems(self): + request = OperatingSystems.get_operating_systems() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_operating_systems_with_filter_string(self): + request = OperatingSystems.get_operating_systems( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_operating_systems_with_filter_id(self): + request = OperatingSystems.get_operating_systems(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_operating_systems_with_details(self): + request = OperatingSystems.get_operating_systems(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = OperatingSystems.get_operating_systems(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_operating_system(self): + request = OperatingSystems.get_operating_system("operating_system_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_operating_system_with_details(self): + request = OperatingSystems.get_operating_system( + "operating_system_id", details=True + ) + self.assertEqual( + bytes(request), + b'', + ) + request = OperatingSystems.get_operating_system( + "operating_system_id", details=False + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_operating_system(self): + request = OperatingSystems.modify_operating_system( + "operating_system_id" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"", + ) + + def test_modify_operating_system_with_comment(self): + request = OperatingSystems.modify_operating_system( + "operating_system_id", comment="comment" + ) + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_operating_system_missing_operating_system_id(self): + with self.assertRaises(RequiredArgument): + OperatingSystems.modify_operating_system(None) + + with self.assertRaises(RequiredArgument): + OperatingSystems.modify_operating_system("") diff --git a/tests/protocols/gmp/requests/v224/test_overrides.py b/tests/protocols/gmp/requests/v224/test_overrides.py new file mode 100644 index 000000000..6ea77aed3 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_overrides.py @@ -0,0 +1,509 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest +from decimal import Decimal + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Overrides + + +class OverridesTestCase(unittest.TestCase): + def test_create_override(self): + request = Overrides.create_override("foo", nvt_oid="oid1") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"", + ) + + def test_create_override_missing_text(self): + with self.assertRaises(RequiredArgument): + Overrides.create_override(None, "od1") + + with self.assertRaises(RequiredArgument): + Overrides.create_override("", "oid1") + + def test_create_override_missing_nvt_oid(self): + with self.assertRaises(RequiredArgument): + Overrides.create_override("foo", None) + + with self.assertRaises(RequiredArgument): + Overrides.create_override("foo", "") + + def test_create_override_with_hosts(self): + request = Overrides.create_override("foo", nvt_oid="oid1", hosts=[]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", hosts=["h1", "h2"] + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"h1,h2" + b"", + ) + + def test_create_override_with_port(self): + request = Overrides.create_override( + "foo", nvt_oid="oid1", port="666/udp" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"666/udp" + b"", + ) + + def test_create_override_with_result_id(self): + request = Overrides.create_override( + "foo", nvt_oid="oid1", result_id="r1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b'' + b"", + ) + + def test_create_override_with_task_id(self): + request = Overrides.create_override("foo", nvt_oid="oid1", task_id="t1") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b'' + b"", + ) + + def test_create_override_with_severity(self): + request = Overrides.create_override( + "foo", nvt_oid="oid1", severity="5.5" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + request = Overrides.create_override("foo", nvt_oid="oid1", severity=5.5) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", severity=Decimal(5.5) + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + def test_create_override_with_new_severity(self): + request = Overrides.create_override( + "foo", nvt_oid="oid1", new_severity="5.5" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", new_severity=5.5 + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", new_severity=Decimal(5.5) + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5.5" + b"", + ) + + def test_create_override_with_days_active(self): + request = Overrides.create_override( + "foo", nvt_oid="oid1", days_active=0 + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"0" + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", days_active=5 + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"5" + b"", + ) + + request = Overrides.create_override( + "foo", nvt_oid="oid1", days_active=-1 + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"-1" + b"", + ) + + def test_create_override_with_invalid_port(self): + with self.assertRaises(InvalidArgument): + Overrides.create_override("foo", nvt_oid="oid1", port="invalid") + + with self.assertRaises(InvalidArgument): + Overrides.create_override("foo", nvt_oid="oid1", port="123") + + with self.assertRaises(InvalidArgument): + Overrides.create_override( + text="foo", nvt_oid="oid1", port="tcp/123" + ) + + def test_modify_override(self): + request = Overrides.modify_override("o1", "foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_override_missing_override_id(self): + with self.assertRaises(RequiredArgument): + Overrides.modify_override(None, "foo") + + with self.assertRaises(RequiredArgument): + Overrides.modify_override("", "foo") + + def test_modify_override_missing_text(self): + with self.assertRaises(RequiredArgument): + Overrides.modify_override("o1", None) + + with self.assertRaises(RequiredArgument): + Overrides.modify_override("o1", "") + + def test_modify_override_with_days_active(self): + request = Overrides.modify_override("o1", "foo", days_active=0) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"0" + b"", + ) + + request = Overrides.modify_override("o1", "foo", days_active=5) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5" + b"", + ) + + request = Overrides.modify_override("o1", "foo", days_active=-1) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"-1" + b"", + ) + + def test_modify_override_with_port(self): + request = Overrides.modify_override("o1", "foo", port="666/udp") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"666/udp" + b"", + ) + + def test_modify_override_with_hosts(self): + request = Overrides.modify_override("o1", "foo", hosts=["h1"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"h1" + b"", + ) + + request = Overrides.modify_override("o1", "foo", hosts=["h1", "h2"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"h1,h2" + b"", + ) + + def test_modify_override_with_result_id(self): + request = Overrides.modify_override("o1", "foo", result_id="r1") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b'' + b"", + ) + + def test_modify_override_with_task_id(self): + request = Overrides.modify_override("o1", "foo", task_id="t1") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b'' + b"", + ) + + def test_modify_override_with_severity(self): + request = Overrides.modify_override("o1", "foo", severity="5.5") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Overrides.modify_override("o1", "foo", severity=5.5) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Overrides.modify_override("o1", "foo", severity=Decimal(5.5)) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + def test_modify_override_with_new_severity(self): + request = Overrides.modify_override("o1", "foo", new_severity="5.5") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Overrides.modify_override("o1", "foo", new_severity=5.5) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + request = Overrides.modify_override( + "o1", "foo", new_severity=Decimal(5.5) + ) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"5.5" + b"", + ) + + def test_modify_override_with_invalid_port(self): + with self.assertRaises(InvalidArgument): + Overrides.modify_override("o1", "foo", port="invalid") + + with self.assertRaises(InvalidArgument): + Overrides.modify_override("o1", "foo", port="123") + + with self.assertRaises(InvalidArgument): + Overrides.modify_override("o1", "foo", port="tcp/123") + + def test_clone_override(self): + request = Overrides.clone_override("o1") + + self.assertEqual( + bytes(request), + b"o1", + ) + + def test_clone_override_missing_override_id(self): + with self.assertRaises(RequiredArgument): + Overrides.clone_override(None) + + with self.assertRaises(RequiredArgument): + Overrides.clone_override("") + + def test_delete_override(self): + request = Overrides.delete_override("o1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_override_ultimate(self): + request = Overrides.delete_override("o1", ultimate=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Overrides.delete_override("o1", ultimate=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_override_missing_override_id(self): + with self.assertRaises(RequiredArgument): + Overrides.delete_override(None) + + with self.assertRaises(RequiredArgument): + Overrides.delete_override("") + + def test_get_overrides(self): + request = Overrides.get_overrides() + + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_overrides_with_filter_string(self): + request = Overrides.get_overrides(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_get_overrides_with_filter_id(self): + request = Overrides.get_overrides(filter_id="f1") + + self.assertEqual(bytes(request), b'') + + def test_get_overrides_with_details(self): + request = Overrides.get_overrides(details=True) + + self.assertEqual(bytes(request), b'') + + request = Overrides.get_overrides(details=False) + + self.assertEqual(bytes(request), b'') + + def test_get_overrides_with_result(self): + request = Overrides.get_overrides(result=True) + + self.assertEqual(bytes(request), b'') + + request = Overrides.get_overrides(result=False) + + self.assertEqual(bytes(request), b'') + + def test_get_override(self): + request = Overrides.get_override("o1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_override_missing_override_id(self): + with self.assertRaises(RequiredArgument): + Overrides.get_override(None) + + with self.assertRaises(RequiredArgument): + Overrides.get_override("") diff --git a/tests/protocols/gmp/requests/v224/test_permissions.py b/tests/protocols/gmp/requests/v224/test_permissions.py new file mode 100644 index 000000000..b44cb2b52 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_permissions.py @@ -0,0 +1,310 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Permissions, PermissionSubjectType + + +class PermissionsTestCase(unittest.TestCase): + def test_clone_permission(self): + request = Permissions.clone_permission("permission_id") + self.assertEqual( + bytes(request), + b"permission_id", + ) + + def test_clone_permission_missing_permission_id(self): + with self.assertRaises(RequiredArgument): + Permissions.clone_permission(None) + + with self.assertRaises(RequiredArgument): + Permissions.clone_permission("") + + def test_create_permission(self): + request = Permissions.create_permission( + "name", "subject_id", PermissionSubjectType.USER + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"user" + b"" + b"", + ) + + request = Permissions.create_permission( + "name", + "subject_id", + "user", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"user" + b"" + b"", + ) + + def test_create_permission_with_resource(self): + request = Permissions.create_permission( + "name", + "subject_id", + PermissionSubjectType.USER, + resource_id="resource_id", + resource_type="alert", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"user" + b"" + b'' + b"alert" + b"" + b"", + ) + + def test_create_permission_with_comment(self): + request = Permissions.create_permission( + "name", + "subject_id", + PermissionSubjectType.USER, + comment="comment", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"user" + b"" + b"comment" + b"", + ) + + def test_create_permission_missing_name(self): + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + None, "subject_id", PermissionSubjectType.USER + ) + + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + "", "subject_id", PermissionSubjectType.USER + ) + + def test_create_permission_missing_subject_id(self): + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + "name", None, PermissionSubjectType.USER + ) + + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + "name", "", PermissionSubjectType.USER + ) + + def test_create_permission_with_resource_missing_resource_id(self): + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + "name", + "subject_id", + PermissionSubjectType.USER, + resource_type="alert", + ) + + def test_create_permission_with_resource_missing_resource_type(self): + with self.assertRaises(RequiredArgument): + Permissions.create_permission( + "name", + "subject_id", + PermissionSubjectType.USER, + resource_id="resource_id", + ) + + def test_create_permission_invalid_subject_type(self): + with self.assertRaises(InvalidArgument): + Permissions.create_permission("name", "subject_id", "invalid") + + def test_create_permission_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + Permissions.create_permission( + "name", + "subject_id", + PermissionSubjectType.USER, + resource_id="resource_id", + resource_type="invalid", + ) + + def test_delete_permission(self): + request = Permissions.delete_permission("permission_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_permission_ultimate(self): + request = Permissions.delete_permission("permission_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Permissions.delete_permission("permission_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_permission_missing_permission_id(self): + with self.assertRaises(RequiredArgument): + Permissions.delete_permission(None) + + with self.assertRaises(RequiredArgument): + Permissions.delete_permission("") + + def test_get_permissions(self): + request = Permissions.get_permissions() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_permissions_with_filter_string(self): + request = Permissions.get_permissions(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_permissions_with_filter_id(self): + request = Permissions.get_permissions(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_permissions_with_trash(self): + request = Permissions.get_permissions(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Permissions.get_permissions(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_permission(self): + request = Permissions.get_permission("permission_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_permission_missing_permission_id(self): + with self.assertRaises(RequiredArgument): + Permissions.get_permission(None) + + with self.assertRaises(RequiredArgument): + Permissions.get_permission("") + + def test_modify_permission(self): + request = Permissions.modify_permission("permission_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_permission_with_name(self): + request = Permissions.modify_permission("permission_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_permission_with_comment(self): + request = Permissions.modify_permission( + "permission_id", comment="comment" + ) + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_permission_with_resource(self): + request = Permissions.modify_permission( + "permission_id", resource_id="resource_id", resource_type="alert" + ) + self.assertEqual( + bytes(request), + b'' + b'' + b"alert" + b"" + b"", + ) + + def test_modify_permission_with_subject(self): + request = Permissions.modify_permission( + "permission_id", subject_id="subject_id", subject_type="user" + ) + self.assertEqual( + bytes(request), + b'' + b'' + b"user" + b"" + b"", + ) + + def test_modify_permission_with_resource_missing_resource_id(self): + with self.assertRaises(RequiredArgument): + Permissions.modify_permission( + "permission_id", resource_type="alert" + ) + + def test_modify_permission_with_resource_missing_resource_type(self): + with self.assertRaises(RequiredArgument): + Permissions.modify_permission( + "permission_id", resource_id="resource_id" + ) + + def test_modify_permission_with_subject_missing_subject_id(self): + with self.assertRaises(RequiredArgument): + Permissions.modify_permission("permission_id", subject_type="user") + + def test_modify_permission_with_subject_missing_subject_type(self): + with self.assertRaises(RequiredArgument): + Permissions.modify_permission( + "permission_id", subject_id="subject_id" + ) + + def test_modify_permission_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + Permissions.modify_permission( + "permission_id", + resource_id="resource_id", + resource_type="invalid", + ) + + def test_modify_permission_invalid_subject_type(self): + with self.assertRaises(InvalidArgument): + Permissions.modify_permission( + "permission_id", subject_type="invalid", subject_id="subject_id" + ) diff --git a/tests/protocols/gmp/requests/v224/test_policies.py b/tests/protocols/gmp/requests/v224/test_policies.py new file mode 100644 index 000000000..4f64bf196 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_policies.py @@ -0,0 +1,507 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Policies + +POLICY_XML_STRING = ( + '' + '' + "Foobar" + "Foobar config" + "2018-11-09T10:48:03Z" + "2018-11-09T10:48:03Z" + "" + "" +) + + +class PoliciesTestCase(unittest.TestCase): + def test_clone_policy(self): + request = Policies.clone_policy("policy_id") + self.assertEqual( + bytes(request), + b"policy_id", + ) + + def test_clone_policy_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.clone_policy(None) + + with self.assertRaises(RequiredArgument): + Policies.clone_policy("") + + def test_create_policy(self): + request = Policies.create_policy("name") + self.assertEqual( + bytes(request), + b"" + b"085569ce-73ed-11df-83c3-002264764cea" + b"name" + b"policy" + b"", + ) + + def test_create_policy_with_policy_id(self): + request = Policies.create_policy("name", policy_id="policy_id") + self.assertEqual( + bytes(request), + b"" + b"policy_id" + b"name" + b"policy" + b"", + ) + + def test_create_policy_with_comment(self): + request = Policies.create_policy("name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"comment" + b"085569ce-73ed-11df-83c3-002264764cea" + b"name" + b"policy" + b"", + ) + + def test_delete_policy(self): + request = Policies.delete_policy("policy_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_policy_with_ultimate(self): + request = Policies.delete_policy("policy_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.delete_policy("policy_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies(self): + request = Policies.get_policies() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies_with_trash(self): + request = Policies.get_policies(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policies(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies_with_details(self): + request = Policies.get_policies(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policies(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies_with_families(self): + request = Policies.get_policies(families=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policies(families=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies_with_preferences(self): + request = Policies.get_policies(preferences=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policies(preferences=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policies_with_audits(self): + request = Policies.get_policies(audits=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policies(audits=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policy(self): + request = Policies.get_policy("policy_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policy_with_audits(self): + request = Policies.get_policy("policy_id", audits=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Policies.get_policy("policy_id", audits=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_policy_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.get_policy(None) + + with self.assertRaises(RequiredArgument): + Policies.get_policy("") + + def test_import_policy(self): + request = Policies.import_policy(POLICY_XML_STRING) + self.assertEqual( + bytes(request), + b"" + b'' + b'' + b"Foobar" + b"Foobar config" + b"2018-11-09T10:48:03Z" + b"2018-11-09T10:48:03Z" + b"" + b"" + b"", + ) + + def test_import_policy_missing_policy_xml(self): + with self.assertRaises(RequiredArgument): + Policies.import_policy(None) + + with self.assertRaises(RequiredArgument): + Policies.import_policy("") + + def test_import_policy_invalid_xml(self): + with self.assertRaises(InvalidArgument): + Policies.import_policy("abcdef") + + def test_modify_policy_set_nvt_preference(self): + request = Policies.modify_policy_set_nvt_preference( + "policy_id", "name", "oid" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b"name" + b"" + b"", + ) + + def test_modify_policy_set_nvt_preference_with_value(self): + request = Policies.modify_policy_set_nvt_preference( + "policy_id", "name", "oid", value="bar" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b"name" + b"YmFy" + b"" + b"", + ) + + def test_modify_policy_set_nvt_preference_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference(None, "name", "oid") + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference("", "name", "oid") + + def test_modify_policy_set_nvt_preference_missing_name(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference("policy_id", None, "oid") + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference("policy_id", "", "oid") + + def test_modify_policy_set_nvt_preference_missing_nvt_oid(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference("policy_id", "name", None) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_preference("policy_id", "name", "") + + def test_modify_policy_set_name(self): + request = Policies.modify_policy_set_name("policy_id", "name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_policy_set_name_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_name(None, "name") + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_name("", "name") + + def test_modify_policy_set_name_missing_name(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_name("policy_id", None) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_name("policy_id", "") + + def test_modify_policy_set_comment(self): + request = Policies.modify_policy_set_comment("policy_id", None) + self.assertEqual( + bytes(request), + b'' + b"" + b"", + ) + + request = Policies.modify_policy_set_comment("policy_id", "comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_policy_set_comment_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_comment(None, "comment") + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_comment("", "comment") + + def test_modify_policy_set_scanner_preference(self): + request = Policies.modify_policy_set_scanner_preference( + "policy_id", + "name", + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"name" + b"" + b"", + ) + + def test_modify_policy_set_scanner_preference_with_value(self): + request = Policies.modify_policy_set_scanner_preference( + "policy_id", + "name", + value="bar", + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"name" + b"YmFy" + b"" + b"", + ) + + def test_modify_policy_set_scanner_preference_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_scanner_preference(None, "name") + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_scanner_preference("", "name") + + def test_modify_policy_set_scanner_preference_missing_name(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_scanner_preference("policy_id", None) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_scanner_preference("policy_id", "") + + def test_modify_policy_set_nvt_selection(self): + request = Policies.modify_policy_set_nvt_selection( + "policy_id", + "name", + ["oid"], + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"name" + b'' + b"" + b"", + ) + + request = Policies.modify_policy_set_nvt_selection( + "policy_id", + "name", + ["oid1", "oid2"], + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"name" + b'' + b'' + b"" + b"", + ) + + def test_modify_policy_set_nvt_selection_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_selection(None, "name", ["oid"]) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_selection("", "name", ["oid"]) + + def test_modify_policy_set_nvt_selection_missing_family(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_selection("policy_id", None, ["oid"]) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_nvt_selection("policy_id", "", ["oid"]) + + def test_modify_policy_set_family_selection(self): + request = Policies.modify_policy_set_family_selection( + "policy_id", + [("name", True, True)], + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"name" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = Policies.modify_policy_set_family_selection( + "policy_id", + [("name1", True, True), ("name2", True, False)], + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"name1" + b"1" + b"1" + b"" + b"" + b"name2" + b"0" + b"1" + b"" + b"" + b"", + ) + + def test_modify_policy_set_family_selection_with_auto_add_new_families( + self, + ): + request = Policies.modify_policy_set_family_selection( + "policy_id", + [("name", True, True)], + auto_add_new_families=True, + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"name" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = Policies.modify_policy_set_family_selection( + "policy_id", + [("name", True, True)], + auto_add_new_families=False, + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"0" + b"" + b"name" + b"1" + b"1" + b"" + b"" + b"", + ) + + def test_modify_policy_set_family_selection_missing_policy_id(self): + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_family_selection( + None, [("name", True, True)] + ) + + with self.assertRaises(RequiredArgument): + Policies.modify_policy_set_family_selection( + "", [("name", True, True)] + ) + + def test_modify_policy_set_family_selection_invalid_families(self): + with self.assertRaises(InvalidArgument): + Policies.modify_policy_set_family_selection( + "policy_id", [("name", True, True, True)] + ) + + with self.assertRaises(InvalidArgument): + Policies.modify_policy_set_family_selection( + "policy_id", [("name", True)] + ) diff --git a/tests/protocols/gmp/requests/v224/test_port_lists.py b/tests/protocols/gmp/requests/v224/test_port_lists.py new file mode 100644 index 000000000..f2b624d3b --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_port_lists.py @@ -0,0 +1,338 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import PortLists, PortRangeType + + +class PortListsTestCase(unittest.TestCase): + def test_clone(self) -> None: + request = PortLists.clone_port_list("a1") + + self.assertEqual( + bytes(request), + b"a1", + ) + + def test_clone_missing_id(self): + with self.assertRaises(RequiredArgument): + PortLists.clone_port_list("") + + with self.assertRaises(RequiredArgument): + PortLists.clone_port_list(None) + + def test_create_port_list_missing_name(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_list(name=None, port_range="T:1-1234") + + with self.assertRaises(RequiredArgument): + PortLists.create_port_list(name="", port_range="T:1-1234") + + def test_create_port_list_missing_port_range(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_list(name="foo", port_range=None) + + with self.assertRaises(RequiredArgument): + PortLists.create_port_list(name="foo", port_range="") + + def test_create_port_list(self): + request = PortLists.create_port_list(name="foo", port_range="T:1-1234") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"T:1-1234" + b"", + ) + + def test_create_port_list_with_comment(self): + request = PortLists.create_port_list( + name="foo", port_range="T:1-1234", comment="lorem" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"T:1-1234" + b"lorem" + b"", + ) + + def test_create_port_range_missing_port_list_id(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id=None, + start=1, + end=1234, + port_range_type=PortRangeType.TCP, + ) + + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="", + start=1, + end=1234, + port_range_type=PortRangeType.TCP, + ) + + def test_create_port_range_missing_start(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", + start=None, + end=1234, + port_range_type=PortRangeType.TCP, + ) + + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", + start="", + end=1234, + port_range_type=PortRangeType.TCP, + ) + + def test_create_port_range_missing_end(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", + start=1, + end=None, + port_range_type=PortRangeType.TCP, + ) + + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", + start=1, + end="", + port_range_type=PortRangeType.TCP, + ) + + def test_create_port_range_missing_port_range_type(self): + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", start=1, end=1234, port_range_type=None + ) + + with self.assertRaises(RequiredArgument): + PortLists.create_port_range( + port_list_id="pl1", start=1, end=1234, port_range_type="" + ) + + def test_create_port_range_invalid_port_range_type(self): + with self.assertRaises(InvalidArgument): + PortLists.create_port_range( + port_list_id="pl1", start=1, end=1234, port_range_type="blubb" + ) + + def test_create_port_range(self): + request = PortLists.create_port_range( + port_list_id="pl1", + start=1, + end=1234, + port_range_type=PortRangeType.TCP, + ) + + self.assertEqual( + bytes(request), + b"" + b'' + b"1" + b"1234" + b"TCP" + b"", + ) + + request = PortLists.create_port_range( + port_list_id="pl1", + start=1, + end=1234, + port_range_type=PortRangeType.UDP, + ) + + self.assertEqual( + bytes(request), + b"" + b'' + b"1" + b"1234" + b"UDP" + b"", + ) + + request = PortLists.create_port_range( + port_list_id="pl1", + start="1", + end="1234", + port_range_type=PortRangeType.TCP, + ) + + self.assertEqual( + bytes(request), + b"" + b'' + b"1" + b"1234" + b"TCP" + b"", + ) + + def test_create_port_range_with_comment(self): + request = PortLists.create_port_range( + port_list_id="pl1", + start=1, + end=1234, + port_range_type=PortRangeType.TCP, + comment="lorem", + ) + + self.assertEqual( + bytes(request), + b"" + b'' + b"1" + b"1234" + b"TCP" + b"lorem" + b"", + ) + + def test_delete(self): + request = PortLists.delete_port_list("a1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_ultimate(self): + request = PortLists.delete_port_list("a1", ultimate=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_missing_id(self): + with self.assertRaises(RequiredArgument): + PortLists.delete_port_list(None) + + with self.assertRaises(RequiredArgument): + PortLists.delete_port_list("") + + def test_delete_port_range(self): + request = PortLists.delete_port_range("a1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_port_range_missing_id(self): + with self.assertRaises(RequiredArgument): + PortLists.delete_port_range(None) + + with self.assertRaises(RequiredArgument): + PortLists.delete_port_range("") + + def test_get_port_lists(self): + request = PortLists.get_port_lists() + + self.assertEqual(bytes(request), b"") + + def test_get_port_lists_with_filter_string(self): + request = PortLists.get_port_lists(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_get_port_lists_with_filter_id(self): + request = PortLists.get_port_lists(filter_id="f1") + + self.assertEqual(bytes(request), b'') + + def test_get_port_lists_with_trash(self): + request = PortLists.get_port_lists(trash=True) + + self.assertEqual(bytes(request), b'') + + request = PortLists.get_port_lists(trash=False) + + self.assertEqual(bytes(request), b'') + + def test_get_port_lists_with_details(self): + request = PortLists.get_port_lists(details=True) + + self.assertEqual(bytes(request), b'') + + request = PortLists.get_port_lists(details=False) + + self.assertEqual(bytes(request), b'') + + def test_get_port_lists_with_targets(self): + request = PortLists.get_port_lists(targets=True) + + self.assertEqual(bytes(request), b'') + + request = PortLists.get_port_lists(targets=False) + + self.assertEqual(bytes(request), b'') + + def test_get_port_list(self): + request = PortLists.get_port_list(port_list_id="port_list_id") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_port_list_missing_port_list_id(self): + with self.assertRaises(RequiredArgument): + PortLists.get_port_list(port_list_id=None) + + with self.assertRaises(RequiredArgument): + PortLists.get_port_list(port_list_id="") + + with self.assertRaises(RequiredArgument): + PortLists.get_port_list("") + + def test_modify_port_list(self): + request = PortLists.modify_port_list(port_list_id="p1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_modify_port_list_missing_port_list_id(self): + with self.assertRaises(RequiredArgument): + PortLists.modify_port_list(port_list_id=None) + + with self.assertRaises(RequiredArgument): + PortLists.modify_port_list(port_list_id="") + + with self.assertRaises(RequiredArgument): + PortLists.modify_port_list("") + + def test_modify_port_list_with_comment(self): + request = PortLists.modify_port_list(port_list_id="p1", comment="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_port_list_with_name(self): + request = PortLists.modify_port_list(port_list_id="p1", name="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) diff --git a/tests/protocols/gmp/requests/v224/test_report_formats.py b/tests/protocols/gmp/requests/v224/test_report_formats.py new file mode 100644 index 000000000..83711821d --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_report_formats.py @@ -0,0 +1,300 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ReportFormats, ReportFormatType + + +class ReportFormatsTestCase(unittest.TestCase): + + def test_clone_report_format(self): + request = ReportFormats.clone_report_format("report_format_id") + self.assertEqual( + bytes(request), + b"" + b"report_format_id" + b"", + ) + + request = ReportFormats.clone_report_format(ReportFormatType.PDF) + self.assertEqual( + bytes(request), + b"" + b"c402cc3e-b531-11e1-9163-406186ea4fc5" + b"", + ) + + def test_clone_report_format_missing_report_format_id(self): + with self.assertRaises(RequiredArgument): + ReportFormats.clone_report_format(None) + + with self.assertRaises(RequiredArgument): + ReportFormats.clone_report_format("") + + def test_delete_report_format(self): + request = ReportFormats.delete_report_format("report_format_id") + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.delete_report_format(ReportFormatType.PDF) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_report_format_with_ultimate(self): + request = ReportFormats.delete_report_format( + "report_format_id", ultimate=True + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.delete_report_format( + ReportFormatType.PDF, ultimate=False + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_report_format_missing_report_format_id(self): + with self.assertRaises(RequiredArgument): + ReportFormats.delete_report_format(None) + + with self.assertRaises(RequiredArgument): + ReportFormats.delete_report_format("") + + def test_get_report_formats(self): + request = ReportFormats.get_report_formats() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_report_formats_with_filter_string(self): + request = ReportFormats.get_report_formats( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_formats_with_filter_id(self): + request = ReportFormats.get_report_formats(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_formats_with_details(self): + request = ReportFormats.get_report_formats(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.get_report_formats(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_formats_with_alerts(self): + request = ReportFormats.get_report_formats(alerts=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.get_report_formats(alerts=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_formats_with_params(self): + request = ReportFormats.get_report_formats(params=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.get_report_formats(params=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_formats_with_trash(self): + request = ReportFormats.get_report_formats(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.get_report_formats(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_format(self): + request = ReportFormats.get_report_format("report_format_id") + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.get_report_format(ReportFormatType.PDF) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_format_missing_report_format_id(self): + with self.assertRaises(RequiredArgument): + ReportFormats.get_report_format(None) + + with self.assertRaises(RequiredArgument): + ReportFormats.get_report_format("") + + def test_import_report_format(self): + REPORT_FORMAT_XML_STRING = ( + '' + '' + "Foobar" + "Foobar report_format" + "2018-11-09T10:48:03Z" + "2018-11-09T10:48:03Z" + "" + "" + ) + request = ReportFormats.import_report_format(REPORT_FORMAT_XML_STRING) + self.assertEqual( + bytes(request), + b"" + b'' + b'' + b"Foobar" + b"Foobar report_format" + b"2018-11-09T10:48:03Z" + b"2018-11-09T10:48:03Z" + b"" + b"" + b"", + ) + + def test_import_report_format_invalid_report_format(self): + with self.assertRaises(InvalidArgument): + ReportFormats.import_report_format("invalid_report_format") + + def test_modify_report_format(self): + request = ReportFormats.modify_report_format("report_format_id") + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.modify_report_format(ReportFormatType.PDF) + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_report_format_with_active(self): + request = ReportFormats.modify_report_format( + "report_format_id", active=True + ) + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = ReportFormats.modify_report_format( + ReportFormatType.PDF, active=False + ) + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_report_format_with_name(self): + request = ReportFormats.modify_report_format( + "report_format_id", name="Foobar" + ) + self.assertEqual( + bytes(request), + b'' + b"Foobar" + b"", + ) + + def test_modify_report_format_with_summary(self): + request = ReportFormats.modify_report_format( + "report_format_id", summary="Foobar report_format" + ) + self.assertEqual( + bytes(request), + b'' + b"Foobar report_format" + b"", + ) + + def test_modify_report_format_with_param_name(self): + request = ReportFormats.modify_report_format( + "report_format_id", param_name="Foobar" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"Foobar" + b"" + b"", + ) + + def test_modify_report_format_with_param_name_and_value(self): + request = ReportFormats.modify_report_format( + "report_format_id", param_name="Foobar", param_value="42" + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"Foobar" + b"42" + b"" + b"", + ) + + def test_verify_report_format(self): + request = ReportFormats.verify_report_format("report_format_id") + self.assertEqual( + bytes(request), + b'', + ) + + request = ReportFormats.verify_report_format(ReportFormatType.PDF) + self.assertEqual( + bytes(request), + b'', + ) + + def test_verify_report_format_missing_report_format_id(self): + with self.assertRaises(RequiredArgument): + ReportFormats.verify_report_format(None) + + with self.assertRaises(RequiredArgument): + ReportFormats.verify_report_format("") diff --git a/tests/protocols/gmp/requests/v224/test_reports.py b/tests/protocols/gmp/requests/v224/test_reports.py new file mode 100644 index 000000000..f165ecf38 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_reports.py @@ -0,0 +1,227 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Reports + +REPORT_XML_STRING = ( + '' + '' + '' + "0.0" + '' + "132.67.253.114" + "" +) + + +class ReportsTestCase(unittest.TestCase): + def test_delete_report(self): + request = Reports.delete_report("report_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_report_missing_report_id(self): + with self.assertRaises(RequiredArgument): + Reports.delete_report(None) + + with self.assertRaises(RequiredArgument): + Reports.delete_report("") + + def test_get_report(self): + request = Reports.get_report("report_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_with_filter_string(self): + request = Reports.get_report("report_id", filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_with_filter_id(self): + request = Reports.get_report("report_id", filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_with_delta_report_id(self): + request = Reports.get_report( + "report_id", delta_report_id="delta_report_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_with_report_format_id(self): + request = Reports.get_report( + "report_id", report_format_id="report_format_id" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_with_ignore_pagination(self): + request = Reports.get_report("report_id", ignore_pagination=True) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_report_missing_report_id(self): + with self.assertRaises(RequiredArgument): + Reports.get_report(None) + + with self.assertRaises(RequiredArgument): + Reports.get_report("") + + def test_get_reports(self): + request = Reports.get_reports() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_reports_with_filter_string(self): + request = Reports.get_reports(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_reports_with_filter_id(self): + request = Reports.get_reports(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_reports_with_note_details(self): + request = Reports.get_reports(note_details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Reports.get_reports(note_details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_reports_with_override_details(self): + request = Reports.get_reports(override_details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Reports.get_reports(override_details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_reports_with_details(self): + request = Reports.get_reports(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Reports.get_reports(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_reports_with_ignore_pagination(self): + request = Reports.get_reports(ignore_pagination=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Reports.get_reports(ignore_pagination=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_import_report(self): + request = Reports.import_report(REPORT_XML_STRING, "task_id") + self.assertEqual( + bytes(request), + b"" + b'' + b'' + b'' + b'' + b"0.0" + b'' + b"132.67.253.114" + b"" + b"", + ) + + def test_import_report_with_in_assets(self): + request = Reports.import_report( + REPORT_XML_STRING, "task_id", in_assets=False + ) + self.assertEqual( + bytes(request), + b"" + b'' + b"0" + b'' + b'' + b'' + b"0.0" + b'' + b"132.67.253.114" + b"" + b"", + ) + + request = Reports.import_report( + REPORT_XML_STRING, "task_id", in_assets=True + ) + self.assertEqual( + bytes(request), + b"" + b'' + b"1" + b'' + b'' + b'' + b"0.0" + b'' + b"132.67.253.114" + b"" + b"", + ) + + def test_import_report_missing_report(self): + with self.assertRaises(RequiredArgument): + Reports.import_report(None, "task_id") + + with self.assertRaises(RequiredArgument): + Reports.import_report("", "task_id") + + def test_import_report_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Reports.import_report("report", None) + + with self.assertRaises(RequiredArgument): + Reports.import_report("report", "") diff --git a/tests/protocols/gmp/requests/v224/test_results.py b/tests/protocols/gmp/requests/v224/test_results.py new file mode 100644 index 000000000..93e19a5c7 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_results.py @@ -0,0 +1,91 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Results + + +class ResultsTestCase(unittest.TestCase): + def test_get_result(self): + request = Results.get_result("result_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_result_missing_result_id(self): + with self.assertRaises(RequiredArgument): + Results.get_result(None) + + with self.assertRaises(RequiredArgument): + Results.get_result("") + + def test_get_results(self): + request = Results.get_results() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_results_with_filter_string(self): + request = Results.get_results(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_results_with_filter_id(self): + request = Results.get_results(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_results_with_task_id(self): + request = Results.get_results(task_id="task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_results_with_note_details(self): + request = Results.get_results(note_details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Results.get_results(note_details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_results_with_override_details(self): + request = Results.get_results(override_details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Results.get_results(override_details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_results_with_details(self): + request = Results.get_results(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Results.get_results(details=False) + self.assertEqual( + bytes(request), + b'', + ) diff --git a/tests/protocols/gmp/requests/v224/test_roles.py b/tests/protocols/gmp/requests/v224/test_roles.py new file mode 100644 index 000000000..38d3a5fb6 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_roles.py @@ -0,0 +1,147 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Roles + + +class RolesTestCase(unittest.TestCase): + def test_clone_role(self): + request = Roles.clone_role("role_id") + self.assertEqual( + bytes(request), + b"role_id", + ) + + def test_clone_role_missing_role_id(self): + with self.assertRaises(RequiredArgument): + Roles.clone_role(None) + + with self.assertRaises(RequiredArgument): + Roles.clone_role("") + + def test_create_role(self): + request = Roles.create_role("name") + self.assertEqual( + bytes(request), + b"name", + ) + + def test_create_role_with_comment(self): + request = Roles.create_role("name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"name" + b"comment" + b"", + ) + + def test_create_role_with_users(self): + request = Roles.create_role("name", users=["user1", "user2"]) + self.assertEqual( + bytes(request), + b"" + b"name" + b"user1,user2" + b"", + ) + + def test_create_role_missing_name(self): + with self.assertRaises(RequiredArgument): + Roles.create_role(None) + + with self.assertRaises(RequiredArgument): + Roles.create_role("") + + def test_get_roles(self): + request = Roles.get_roles() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_roles_with_filter_string(self): + request = Roles.get_roles(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_roles_with_filter_id(self): + request = Roles.get_roles(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_roles_with_trash(self): + request = Roles.get_roles(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Roles.get_roles(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_role(self): + request = Roles.get_role("role_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_role_missing_role_id(self): + with self.assertRaises(RequiredArgument): + Roles.get_role(None) + + with self.assertRaises(RequiredArgument): + Roles.get_role("") + + def test_modify_role(self): + request = Roles.modify_role("role_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_role_with_comment(self): + request = Roles.modify_role("role_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_role_with_name(self): + request = Roles.modify_role("role_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_role_with_users(self): + request = Roles.modify_role("role_id", users=["user1", "user2"]) + self.assertEqual( + bytes(request), + b'' + b"user1,user2" + b"", + ) + + def test_modify_role_missing_role_id(self): + with self.assertRaises(RequiredArgument): + Roles.modify_role(None) + + with self.assertRaises(RequiredArgument): + Roles.modify_role("") diff --git a/tests/protocols/gmp/requests/v224/test_scan_configs.py b/tests/protocols/gmp/requests/v224/test_scan_configs.py new file mode 100644 index 000000000..bae26edd3 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_scan_configs.py @@ -0,0 +1,777 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ScanConfigs + + +class ScanConfigsTestCase(unittest.TestCase): + + def test_clone_scan_config(self): + request = ScanConfigs.clone_scan_config("a1") + + self.assertEqual( + bytes(request), b"a1" + ) + + def test_clone_scan_config_missing_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.clone_scan_config("") + + with self.assertRaises(RequiredArgument): + ScanConfigs.clone_scan_config(None) + + def test_create_scan_config(self): + request = ScanConfigs.create_scan_config("a1", "foo") + + self.assertEqual( + bytes(request), + b"a1foo" + b"scan", + ) + + def test_create_scan_config_with_comment(self): + request = ScanConfigs.create_scan_config("a1", "foo", comment="comment") + + self.assertEqual( + bytes(request), + b"commenta1" + b"fooscan", + ) + + def test_create_scan_config_missing_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.create_scan_config("", "foo") + + with self.assertRaises(RequiredArgument): + ScanConfigs.create_scan_config(None, "foo") + + def test_create_scan_config_missing_name(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.create_scan_config("c1", None) + + with self.assertRaises(RequiredArgument): + ScanConfigs.create_scan_config("c1", "") + + def test_delete_scan_config(self): + request = ScanConfigs.delete_scan_config("a1") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_scan_config_ultimate(self): + request = ScanConfigs.delete_scan_config("a1", ultimate=True) + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_scan_config_missing_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.delete_scan_config("") + + with self.assertRaises(RequiredArgument): + ScanConfigs.delete_scan_config(None) + + def test_get_scan_config_preference(self): + request = ScanConfigs.get_scan_config_preference("foo") + + self.assertEqual(bytes(request), b'') + + def test_get_scan_config_preference_missing_name(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.get_scan_config_preference("") + + with self.assertRaises(RequiredArgument): + ScanConfigs.get_scan_config_preference(None) + + def test_get_scan_config_preference_with_nvt_oid(self): + request = ScanConfigs.get_scan_config_preference("foo", nvt_oid="oid") + + self.assertEqual( + bytes(request), b'' + ) + + def test_get_scan_config_preference_with_config_id(self): + request = ScanConfigs.get_scan_config_preference("foo", config_id="c1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_preferences(self): + request = ScanConfigs.get_scan_config_preferences() + + self.assertEqual(bytes(request), b"") + + def test_get_scan_config_preferences_with_nvt_oid(self): + request = ScanConfigs.get_scan_config_preferences(nvt_oid="oid") + + self.assertEqual(bytes(request), b'') + + def test_get_scan_config_preferences_with_config_id(self): + request = ScanConfigs.get_scan_config_preferences(config_id="c1") + + self.assertEqual(bytes(request), b'') + + def test_get_scan_config(self): + request = ScanConfigs.get_scan_config("a1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_with_tasks(self): + request = ScanConfigs.get_scan_config("a1", tasks=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_config_without_scan_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.get_scan_config(None) + + with self.assertRaises(RequiredArgument): + ScanConfigs.get_scan_config("") + + def test_get_scan_configs(self): + request = ScanConfigs.get_scan_configs() + + self.assertEqual(bytes(request), b'') + + def test_get_scan_configs_with_filter_string(self): + request = ScanConfigs.get_scan_configs(filter_string="name=foo") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_with_filter_id(self): + request = ScanConfigs.get_scan_configs(filter_id="f1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_from_trash(self): + request = ScanConfigs.get_scan_configs(trash=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_with_details(self): + request = ScanConfigs.get_scan_configs(details=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_without_details(self): + request = ScanConfigs.get_scan_configs(details=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_with_families(self): + request = ScanConfigs.get_scan_configs(families=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_without_families(self): + request = ScanConfigs.get_scan_configs(families=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_with_preferences(self): + request = ScanConfigs.get_scan_configs(preferences=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_without_preferences(self): + request = ScanConfigs.get_scan_configs(preferences=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_with_tasks(self): + request = ScanConfigs.get_scan_configs(tasks=True) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scan_configs_without_tasks(self): + request = ScanConfigs.get_scan_configs(tasks=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_import_scan_config(self): + CONFIG_XML_STRING = ( + '' + '' + "Foobar" + "Foobar config" + "2018-11-09T10:48:03Z" + "2018-11-09T10:48:03Z" + "" + "" + ) + request = ScanConfigs.import_scan_config(CONFIG_XML_STRING) + + self.assertEqual( + bytes(request), + f"{CONFIG_XML_STRING}".encode( + encoding="utf-8" + ), + ) + + def test_import_missing_scan_config_xml(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.import_scan_config(None) + + with self.assertRaises(RequiredArgument): + ScanConfigs.import_scan_config("") + + def test_import_invalid_xml(self): + with self.assertRaises(InvalidArgument): + ScanConfigs.import_scan_config("abcdef") + + def test_modify_scan_config_set_comment(self): + request = ScanConfigs.modify_scan_config_set_comment("c1") + + self.assertEqual( + bytes(request), + b'', + ) + + request = ScanConfigs.modify_scan_config_set_comment( + "c1", comment="foo" + ) + + self.assertEqual( + bytes(request), + b'foo', + ) + + request = ScanConfigs.modify_scan_config_set_comment("c1", comment=None) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_scan_config_set_comment_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_comment(config_id=None) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_comment("") + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_comment(config_id="") + + def test_modify_scan_config_set_family_selection(self): + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, True)] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, True), ("bar", True, True)] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"bar" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", (("foo", True, True), ("bar", True, True)) + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"bar" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, False), ("bar", False, True)] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"0" + b"1" + b"" + b"" + b"bar" + b"1" + b"0" + b"" + b"" + b"", + ) + + def test_modify_scan_config_set_family_selection_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_family_selection( + None, [("foo", True, True)] + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_family_selection( + "", [("foo", True, True)] + ) + + def test_modify_scan_config_set_family_selection_invalid_families(self): + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", + None, + ) + + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", + "", + ) + + def test_modify_scan_config_set_family_selection_with_auto_add_new_families( + self, + ): + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, True)], auto_add_new_families=True + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, True)], auto_add_new_families=False + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"0" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"", + ) + + def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( + self, + ): + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, True)] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", False, True)] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_family_selection( + "c1", + [("foo", False, True), ("bar", True, False)], + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"bar" + b"0" + b"1" + b"" + b"" + b"", + ) + + def test_modify_scan_config_set_family_selection_with_invalid_arguments( + self, + ): + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", "False", "True")] + ) + + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", True, None)] + ) + + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo", "True", False)] + ) + + with self.assertRaises(InvalidArgument): + ScanConfigs.modify_scan_config_set_family_selection( + "c1", [("foo",)] + ) + + def test_modify_scan_config_set_name(self): + request = ScanConfigs.modify_scan_config_set_name("c1", "foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_scan_config_set_name_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_name(None, name="name") + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_name("", name="name") + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_name(config_id="", name="name") + + def test_modify_scan_config_set_name_missing_name(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_name("c1", None) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_name("c1", "") + + def test_modify_scan_config_set_nvt_preference(self): + request = ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", nvt_oid="o1", name="foo" + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b"foo" + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "foo", "o1" + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b"foo" + b"" + b"", + ) + + def test_modify_scan_config_set_nvt_pref_with_value(self): + request = ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "foo", nvt_oid="o1", value="bar" + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b"foo" + b"YmFy" + b"" + b"", + ) + + def test_modify_scan_config_set_nvt_pref_missing_nvt_oid(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "foo", nvt_oid=None, value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "foo", nvt_oid="", value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "foo", "", value="bar" + ) + + def test_modify_scan_config_nvt_pref_missing_name(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", name=None, nvt_oid="o1", value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", name="", nvt_oid="o1", value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference( + "c1", "", nvt_oid="o1", value="bar" + ) + + def test_modify_scan_config_set_nvt_preference_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference("", "foo", "o1") + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_preference(None, "foo", "o1") + + def test_modify_scan_config_set_nvt_selection(self): + request = ScanConfigs.modify_scan_config_set_nvt_selection( + "c1", "foo", ["o1"] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b'' + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_nvt_selection( + "c1", "foo", ["o1", "o2"] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b'' + b'' + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_nvt_selection( + "c1", "foo", ("o1", "o2") + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b'' + b'' + b"" + b"", + ) + + request = ScanConfigs.modify_scan_config_set_nvt_selection( + "c1", "foo", [] + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b"" + b"", + ) + + def test_modify_scan_config_set_nvt_selection_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_selection( + None, "foo", ["o1"] + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_nvt_selection("", "foo", ["o1"]) + + def test_modify_scan_config_set_nvt_selection_invalid_nvt_oids(self): + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_nvt_selection("c1", "foo", None) + + with self.assertRaises(InvalidArgumentType): + ScanConfigs.modify_scan_config_set_nvt_selection("c1", "foo", "") + + def test_modify_scan_config_set_scanner_pref(self): + request = ScanConfigs.modify_scan_config_set_scanner_preference( + "c1", "foo" + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b"" + b"", + ) + + def test_modify_scan_config_set_scanner_pref_with_value(self): + request = ScanConfigs.modify_scan_config_set_scanner_preference( + "c1", "foo", value="bar" + ) + + self.assertEqual( + bytes(request), + b'' + b"" + b"foo" + b"YmFy" + b"" + b"", + ) + + def test_modify_scan_config_scanner_pref_missing_name(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_scanner_preference( + "c1", name=None, value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_scanner_preference( + "c1", name="", value="bar" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_scanner_preference( + "c1", "", value="bar" + ) + + def test_modify_scan_config_set_scanner_pref_missing_config_id(self): + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_scanner_preference( + None, name="foo" + ) + + with self.assertRaises(RequiredArgument): + ScanConfigs.modify_scan_config_set_scanner_preference( + "", name="foo" + ) diff --git a/tests/protocols/gmp/requests/v224/test_scanners.py b/tests/protocols/gmp/requests/v224/test_scanners.py new file mode 100644 index 000000000..dc481a88e --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_scanners.py @@ -0,0 +1,424 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Scanners, ScannerType + + +class ScannersTestCase(unittest.TestCase): + + def test_create_scanner(self): + request = Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"", + ) + + def test_create_scanner_missing_name(self): + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + None, + "localhost", + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + ) + + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "", + "localhost", + 1234, + scanner_type="2", + credential_id="c1", + ) + + def test_create_scanner_missing_host(self): + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + None, + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + ) + + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "", + 1234, + scanner_type="2", + credential_id="c1", + ) + + def test_create_scanner_missing_port(self): + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + None, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + ) + + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + "", + scanner_type="2", + credential_id="c1", + ) + + def test_create_scanner_missing_scanner_type(self): + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type=None, + credential_id="c1", + ) + + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type="", + credential_id="c1", + ) + + def test_create_scanner_missing_credential_id(self): + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id=None, + ) + + with self.assertRaises(RequiredArgument): + Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type="2", + credential_id="", + ) + + def test_create_scanner_invalid_scanner_type(self): + with self.assertRaises(InvalidArgument): + Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type="invalid", + credential_id="c1", + ) + + def test_create_scanner_with_ca_pub(self): + request = Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + ca_pub="foo", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"foo" + b"", + ) + + def test_create_scanner_with_comment(self): + request = Scanners.create_scanner( + "foo", + "localhost", + 1234, + scanner_type=ScannerType.OPENVAS_SCANNER_TYPE, + credential_id="c1", + comment="foo", + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"foo" + b"", + ) + + def test_modify_scanner(self): + request = Scanners.modify_scanner("s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_scanner_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Scanners.modify_scanner(None) + + with self.assertRaises(RequiredArgument): + Scanners.modify_scanner("") + + def test_modify_scanner_with_comment(self): + request = Scanners.modify_scanner("s1", comment="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_scanner_with_host(self): + request = Scanners.modify_scanner("s1", host="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_scanner_with_port(self): + request = Scanners.modify_scanner("s1", port=1234) + + self.assertEqual( + bytes(request), + b'' + b"1234" + b"", + ) + + request = Scanners.modify_scanner("s1", port="1234") + + self.assertEqual( + bytes(request), + b'' + b"1234" + b"", + ) + + def test_modify_scanner_with_name(self): + request = Scanners.modify_scanner("s1", name="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_scanner_with_ca_pub(self): + request = Scanners.modify_scanner("s1", ca_pub="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_scanner_with_credential_id(self): + request = Scanners.modify_scanner("s1", credential_id="c1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_scanner_with_scanner_type(self): + request = Scanners.modify_scanner( + "s1", scanner_type=ScannerType.OPENVAS_SCANNER_TYPE + ) + + self.assertEqual( + bytes(request), + b'' + b"2" + b"", + ) + + request = Scanners.modify_scanner("s1", scanner_type="2") + + self.assertEqual( + bytes(request), + b'' + b"2" + b"", + ) + + def test_modify_scanner_invalid_scanner_type(self): + with self.assertRaises(InvalidArgument): + Scanners.modify_scanner("s1", scanner_type="invalid") + + with self.assertRaises(ValueError): + Scanners.modify_scanner("s1", scanner_type="") + + with self.assertRaises(InvalidArgument): + Scanners.modify_scanner("s1", scanner_type="-1") + + with self.assertRaises(InvalidArgument): + Scanners.modify_scanner("s1", scanner_type=1) + + def test_get_scanners(self): + request = Scanners.get_scanners() + + self.assertEqual(bytes(request), b"") + + def test_get_scanners_with_filter_string(self): + request = Scanners.get_scanners(filter_string="foo=bar") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scanners_with_filter_id(self): + request = Scanners.get_scanners(filter_id="f1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scanners_with_trash(self): + request = Scanners.get_scanners(trash=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Scanners.get_scanners(trash=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scanners_with_details(self): + request = Scanners.get_scanners(details=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Scanners.get_scanners(details=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scanner(self): + request = Scanners.get_scanner("s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_scanner_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Scanners.get_scanner(None) + + with self.assertRaises(RequiredArgument): + Scanners.get_scanner("") + + def test_verify_scanner(self): + request = Scanners.verify_scanner("s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_verify_scanner_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Scanners.verify_scanner(None) + + with self.assertRaises(RequiredArgument): + Scanners.verify_scanner("") + + def test_clone_scanner(self): + request = Scanners.clone_scanner("s1") + + self.assertEqual( + bytes(request), + b"s1", + ) + + def test_clone_scanner_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Scanners.clone_scanner(None) + + with self.assertRaises(RequiredArgument): + Scanners.clone_scanner("") + + def test_delete_scanner(self): + request = Scanners.delete_scanner("s1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_scanner_ultimate(self): + request = Scanners.delete_scanner("s1", ultimate=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Scanners.delete_scanner("s1", ultimate=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_scanner_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Scanners.delete_scanner(None) + + with self.assertRaises(RequiredArgument): + Scanners.delete_scanner("") diff --git a/tests/protocols/gmp/requests/v224/test_schedules.py b/tests/protocols/gmp/requests/v224/test_schedules.py new file mode 100644 index 000000000..684be1b9d --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_schedules.py @@ -0,0 +1,219 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Schedules + + +class SchedulesTestUnit(unittest.TestCase): + def test_clone_schedule(self): + request = Schedules.clone_schedule("schedule_id") + self.assertEqual( + bytes(request), + b"schedule_id", + ) + + def test_clone_schedule_missing_schedule_id(self): + with self.assertRaises(RequiredArgument): + Schedules.clone_schedule(None) + + with self.assertRaises(RequiredArgument): + Schedules.clone_schedule("") + + def test_create_schedule(self): + request = Schedules.create_schedule("name", "icalendar", "timezone") + self.assertEqual( + bytes(request), + b"" + b"name" + b"icalendar" + b"timezone" + b"", + ) + + def test_create_schedule_with_comment(self): + request = Schedules.create_schedule( + "name", "icalendar", "timezone", comment="comment" + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"icalendar" + b"timezone" + b"comment" + b"", + ) + + def test_create_schedule_missing_name(self): + with self.assertRaises(RequiredArgument): + Schedules.create_schedule(None, "icalendar", "timezone") + + with self.assertRaises(RequiredArgument): + Schedules.create_schedule("", "icalendar", "timezone") + + def test_create_schedule_missing_icalendar(self): + with self.assertRaises(RequiredArgument): + Schedules.create_schedule("name", None, "timezone") + + with self.assertRaises(RequiredArgument): + Schedules.create_schedule("name", "", "timezone") + + def test_create_schedule_missing_timezone(self): + with self.assertRaises(RequiredArgument): + Schedules.create_schedule("name", "icalendar", None) + + with self.assertRaises(RequiredArgument): + Schedules.create_schedule("name", "icalendar", "") + + def test_delete_schedule(self): + request = Schedules.delete_schedule("schedule_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_schedule_with_ultimate(self): + request = Schedules.delete_schedule("schedule_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Schedules.delete_schedule("schedule_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_schedule_missing_schedule_id(self): + with self.assertRaises(RequiredArgument): + Schedules.delete_schedule(None) + + with self.assertRaises(RequiredArgument): + Schedules.delete_schedule("") + + def test_get_schedules(self): + request = Schedules.get_schedules() + self.assertEqual(bytes(request), b"") + + def test_get_schedules_with_filter_string(self): + request = Schedules.get_schedules(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedules_with_filter_id(self): + request = Schedules.get_schedules(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedules_with_trash(self): + request = Schedules.get_schedules(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Schedules.get_schedules(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedules_with_tasks(self): + request = Schedules.get_schedules(tasks=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Schedules.get_schedules(tasks=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedule(self): + request = Schedules.get_schedule("schedule_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedule_with_tasks(self): + request = Schedules.get_schedule("schedule_id", tasks=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Schedules.get_schedule("schedule_id", tasks=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_schedule_missing_schedule_id(self): + with self.assertRaises(RequiredArgument): + Schedules.get_schedule(None) + + with self.assertRaises(RequiredArgument): + Schedules.get_schedule("") + + def test_modify_schedule(self): + request = Schedules.modify_schedule("schedule_id") + self.assertEqual( + bytes(request), b'' + ) + + def test_modify_schedule_with_name(self): + request = Schedules.modify_schedule("schedule_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_schedule_with_comment(self): + request = Schedules.modify_schedule("schedule_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_schedule_with_icalendar(self): + request = Schedules.modify_schedule( + "schedule_id", icalendar="icalendar" + ) + self.assertEqual( + bytes(request), + b'' + b"icalendar" + b"", + ) + + def test_modify_schedule_with_timezone(self): + request = Schedules.modify_schedule("schedule_id", timezone="timezone") + self.assertEqual( + bytes(request), + b'' + b"timezone" + b"", + ) + + def test_modify_schedule_missing_schedule_id(self): + with self.assertRaises(RequiredArgument): + Schedules.modify_schedule(None) + + with self.assertRaises(RequiredArgument): + Schedules.modify_schedule("") diff --git a/tests/protocols/gmp/requests/v224/test_secinfo.py b/tests/protocols/gmp/requests/v224/test_secinfo.py new file mode 100644 index 000000000..f281d2556 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_secinfo.py @@ -0,0 +1,87 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import SecInfo + + +class SecInfoTestCase(unittest.TestCase): + def test_get_info(self): + request = SecInfo.get_info("info_id", "NVT") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_missing_info_id(self): + with self.assertRaises(RequiredArgument): + SecInfo.get_info(None, "NVT") + + with self.assertRaises(RequiredArgument): + SecInfo.get_info("", "NVT") + + def test_get_info_missing_info_type(self): + with self.assertRaises(RequiredArgument): + SecInfo.get_info("info_id", None) + + with self.assertRaises(RequiredArgument): + SecInfo.get_info("info_id", "") + + def test_get_info_invalid_info_type(self): + with self.assertRaises(InvalidArgument): + SecInfo.get_info("info_id", "invalid") + + def test_get_info_list(self): + request = SecInfo.get_info_list("nvt") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_list_with_details(self): + request = SecInfo.get_info_list("nvt", details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = SecInfo.get_info_list("nvt", details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_list_with_filter_string(self): + request = SecInfo.get_info_list("nvt", filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_list_with_filter_id(self): + request = SecInfo.get_info_list("nvt", filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_list_with_name(self): + request = SecInfo.get_info_list("nvt", name="name") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_info_list_missing_info_type(self): + with self.assertRaises(RequiredArgument): + SecInfo.get_info_list(None) + + with self.assertRaises(RequiredArgument): + SecInfo.get_info_list("") + + def test_get_info_list_invalid_info_type(self): + with self.assertRaises(InvalidArgument): + SecInfo.get_info_list("invalid") diff --git a/tests/protocols/gmp/requests/v224/test_system_report.py b/tests/protocols/gmp/requests/v224/test_system_report.py new file mode 100644 index 000000000..fe51ff177 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_system_report.py @@ -0,0 +1,59 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.v224 import SystemReports + + +class SystemReportsTestCase(unittest.TestCase): + def test_get_system_reports(self): + request = SystemReports.get_system_reports() + + self.assertEqual(bytes(request), b"") + + def test_system_reports_with_name(self): + request = SystemReports.get_system_reports(name="foo") + + self.assertEqual(bytes(request), b'') + + def test_system_reports_with_slave_id(self): + request = SystemReports.get_system_reports(slave_id="s1") + + self.assertEqual(bytes(request), b'') + + def test_system_reports_with_brief(self): + request = SystemReports.get_system_reports(brief=True) + + self.assertEqual(bytes(request), b'') + + request = SystemReports.get_system_reports(brief=False) + + self.assertEqual(bytes(request), b'') + + def test_system_reports_with_duration(self): + request = SystemReports.get_system_reports(duration=3600) + + self.assertEqual( + bytes(request), b'' + ) + + def test_system_reports_with_invalid_duration(self): + with self.assertRaises(InvalidArgument): + SystemReports.get_system_reports(duration="") + + def test_system_reports_with_start_time(self): + request = SystemReports.get_system_reports(start_time="01-01-2019") + + self.assertEqual( + bytes(request), b'' + ) + + def test_system_reports_with_end_time(self): + request = SystemReports.get_system_reports(end_time="01-01-2019") + + self.assertEqual( + bytes(request), b'' + ) diff --git a/tests/protocols/gmp/requests/v224/test_tags.py b/tests/protocols/gmp/requests/v224/test_tags.py new file mode 100644 index 000000000..f21dd74d3 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_tags.py @@ -0,0 +1,354 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Tags + + +class TagsTestCase(unittest.TestCase): + def test_clone_tag(self): + request = Tags.clone_tag("tag_id") + self.assertEqual( + bytes(request), + b"tag_id", + ) + + def test_clone_tag_missing_tag_id(self): + with self.assertRaises(RequiredArgument): + Tags.clone_tag(None) + + with self.assertRaises(RequiredArgument): + Tags.clone_tag("") + + def test_create_tag(self): + request = Tags.create_tag("name", "alert") + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b"alert" + b"" + b"", + ) + + def test_create_tag_with_resource_filter(self): + request = Tags.create_tag("name", "alert", resource_filter="filter") + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"alert" + b"" + b"", + ) + + def test_create_tag_with_resource_ids(self): + request = Tags.create_tag("name", "alert", resource_ids=["id1", "id2"]) + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b'' + b'' + b"alert" + b"" + b"", + ) + + def test_create_tag_with_value(self): + request = Tags.create_tag("name", "alert", value="value") + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b"alert" + b"" + b"value" + b"", + ) + + def test_create_tag_with_comment(self): + request = Tags.create_tag("name", "alert", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b"alert" + b"" + b"comment" + b"", + ) + + def test_create_tag_with_active(self): + request = Tags.create_tag("name", "alert", active=True) + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b"alert" + b"" + b"1" + b"", + ) + + request = Tags.create_tag("name", "alert", active=False) + self.assertEqual( + bytes(request), + b"" + b"name" + b"" + b"alert" + b"" + b"0" + b"", + ) + + def test_create_tag_missing_name(self): + with self.assertRaises(RequiredArgument): + Tags.create_tag(None, "alert") + + with self.assertRaises(RequiredArgument): + Tags.create_tag("", "alert") + + def test_create_tag_missing_resource_type(self): + with self.assertRaises(RequiredArgument): + Tags.create_tag("name", None) + + with self.assertRaises(RequiredArgument): + Tags.create_tag("name", "") + + def test_create_tag_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + Tags.create_tag("name", "invalid") + + def test_create_tag_invalid_resource_filter_and_resource_ids(self): + with self.assertRaises(InvalidArgument): + Tags.create_tag( + "name", + "alert", + resource_filter="filter", + resource_ids=["id1", "id2"], + ) + + def test_delete_tag(self): + request = Tags.delete_tag("tag_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_tag_with_ultimate(self): + request = Tags.delete_tag("tag_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tags.delete_tag("tag_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tags(self): + request = Tags.get_tags() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_tags_with_filter_string(self): + request = Tags.get_tags(filter_string="filter") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tags_with_filter_id(self): + request = Tags.get_tags(filter_id="filter") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tags_with_trash(self): + request = Tags.get_tags(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tags.get_tags(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tags_with_names_only(self): + request = Tags.get_tags(names_only=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tags.get_tags(names_only=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tag(self): + request = Tags.get_tag("tag_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tag_missing_tag_id(self): + with self.assertRaises(RequiredArgument): + Tags.get_tag(None) + + with self.assertRaises(RequiredArgument): + Tags.get_tag("") + + def test_modify_tag(self): + request = Tags.modify_tag("tag_id", resource_type="alert") + self.assertEqual( + bytes(request), + b'' + b"" + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_comment(self): + request = Tags.modify_tag( + "tag_id", resource_type="alert", comment="comment" + ) + self.assertEqual( + bytes(request), + b'' + b"comment" + b"" + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_name(self): + request = Tags.modify_tag("tag_id", resource_type="alert", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"" + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_value(self): + request = Tags.modify_tag( + "tag_id", resource_type="alert", value="value" + ) + self.assertEqual( + bytes(request), + b'' + b"value" + b"" + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_active(self): + request = Tags.modify_tag("tag_id", resource_type="alert", active=True) + self.assertEqual( + bytes(request), + b'' + b"1" + b"" + b"alert" + b"" + b"", + ) + + request = Tags.modify_tag("tag_id", resource_type="alert", active=False) + self.assertEqual( + bytes(request), + b'' + b"0" + b"" + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_resource_action(self): + request = Tags.modify_tag("tag_id", resource_action="add") + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_tag_with_resource_filter(self): + request = Tags.modify_tag( + "tag_id", resource_type="alert", resource_filter="filter" + ) + self.assertEqual( + bytes(request), + b'' + b'' + b"alert" + b"" + b"", + ) + + def test_modify_tag_with_resource_ids(self): + request = Tags.modify_tag("tag_id", resource_ids=["id1", "id2"]) + self.assertEqual( + bytes(request), + b'' + b"" + b'' + b'' + b"" + b"", + ) + + def test_modify_tag_missing_tag_id(self): + with self.assertRaises(RequiredArgument): + Tags.modify_tag(None) + + with self.assertRaises(RequiredArgument): + Tags.modify_tag("") + + def test_modify_tag_with_resource_filter_missing_resource_type(self): + with self.assertRaises(RequiredArgument): + Tags.modify_tag("tag_id", resource_filter="filter") + + with self.assertRaises(RequiredArgument): + Tags.modify_tag( + "tag_id", resource_filter="filter", resource_type=None + ) + + with self.assertRaises(RequiredArgument): + Tags.modify_tag( + "tag_id", resource_filter="filter", resource_type="" + ) + + def test_modify_tag_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + Tags.modify_tag("tag_id", resource_type="invalid") diff --git a/tests/protocols/gmp/requests/v224/test_targets.py b/tests/protocols/gmp/requests/v224/test_targets.py new file mode 100644 index 000000000..cbd193c24 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_targets.py @@ -0,0 +1,649 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import AliveTest, Targets + + +class TargetsTestCase(unittest.TestCase): + def test_create_target_missing_name(self): + with self.assertRaises(RequiredArgument): + Targets.create_target(None, hosts=["foo"]) + + with self.assertRaises(RequiredArgument): + Targets.create_target(name=None, hosts=["foo"]) + + with self.assertRaises(RequiredArgument): + Targets.create_target("", hosts=["foo"]) + + def test_create_target_missing_hosts(self): + with self.assertRaises(RequiredArgument): + Targets.create_target(name="foo") + + def test_create_target_with_hosts(self): + request = Targets.create_target("foo", hosts=["foo"]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"", + ) + + request = Targets.create_target("foo", hosts=["foo", "bar"]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo,bar" + b"", + ) + + def test_create_target_with_asset_hosts_filter(self): + request = Targets.create_target("foo", asset_hosts_filter="name=foo") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b"", + ) + + def test_create_target_with_comment(self): + request = Targets.create_target("foo", hosts=["foo"], comment="bar") + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"bar" + b"", + ) + + def test_create_target_with_exclude_hosts(self): + request = Targets.create_target( + "foo", hosts=["foo", "bar"], exclude_hosts=["bar", "ipsum"] + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo,bar" + b"bar,ipsum" + b"", + ) + + def test_create_target_with_ssh_credential(self): + request = Targets.create_target( + "foo", hosts=["foo"], ssh_credential_id="c1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'' + b"", + ) + + def test_create_target_with_ssh_credential_port(self): + request = Targets.create_target( + "foo", hosts=["foo"], ssh_credential_id="c1", ssh_credential_port=22 + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'22' + b"", + ) + + def test_create_target_with_smb_credential_id(self): + request = Targets.create_target( + "foo", hosts=["foo"], smb_credential_id="c1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'' + b"", + ) + + def test_create_target_with_esxi_credential_id(self): + request = Targets.create_target( + "foo", hosts=["foo"], esxi_credential_id="c1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'' + b"", + ) + + def test_create_target_with_snmp_credential_id(self): + request = Targets.create_target( + "foo", hosts=["foo"], snmp_credential_id="c1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'' + b"", + ) + + def test_create_target_with_alive_tests(self): + request = Targets.create_target( + "foo", hosts=["foo"], alive_test=AliveTest.ICMP_PING + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"ICMP Ping" + b"", + ) + + request = Targets.create_target( + "foo", hosts=["foo"], alive_test="icmp ping" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"ICMP Ping" + b"", + ) + + def test_create_target_invalid_alive_tests(self): + with self.assertRaises(InvalidArgument): + Targets.create_target("foo", hosts=["foo"], alive_test="foo") + + def test_create_target_with_allow_simultaneous_ips(self): + request = Targets.create_target( + "foo", hosts=["foo"], allow_simultaneous_ips=True + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"1" + b"", + ) + + request = Targets.create_target( + "foo", hosts=["foo"], allow_simultaneous_ips=False + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"0" + b"", + ) + + def test_create_target_with_reverse_lookup_only(self): + request = Targets.create_target( + "foo", hosts=["foo"], reverse_lookup_only=True + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"1" + b"", + ) + + request = Targets.create_target( + "foo", hosts=["foo"], reverse_lookup_only=False + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"0" + b"", + ) + + def test_create_target_with_reverse_lookup_unify(self): + request = Targets.create_target( + "foo", hosts=["foo"], reverse_lookup_unify=True + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"1" + b"", + ) + + request = Targets.create_target( + "foo", hosts=["foo"], reverse_lookup_unify=False + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"0" + b"", + ) + + def test_create_target_with_port_range(self): + request = Targets.create_target( + "foo", hosts=["foo"], port_range="1-65535" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b"1-65535" + b"", + ) + + def test_create_target_with_port_list_id(self): + request = Targets.create_target( + "foo", hosts=["foo"], port_list_id="pl1" + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b"foo" + b'' + b"", + ) + + def test_modify_target(self): + request = Targets.modify_target("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_target_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Targets.modify_target(None) + + with self.assertRaises(RequiredArgument): + Targets.modify_target("") + + def test_modify_target_with_comment(self): + request = Targets.modify_target("t1", comment="foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_target_with_hosts(self): + request = Targets.modify_target("t1", hosts=["foo"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"" + b"", + ) + + request = Targets.modify_target("t1", hosts=["foo", "bar"]) + + self.assertEqual( + bytes(request), + b'' + b"foo,bar" + b"" + b"", + ) + + def test_modify_target_with_hosts_and_exclude_hosts(self): + request = Targets.modify_target( + "t1", hosts=["foo", "bar"], exclude_hosts=["foo"] + ) + + self.assertEqual( + bytes(request), + b'' + b"foo,bar" + b"foo" + b"", + ) + + def test_modify_target_with_name(self): + request = Targets.modify_target("t1", name="foo") + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + def test_modify_target_with_exclude_hosts(self): + request = Targets.modify_target("t1", exclude_hosts=["foo"]) + + self.assertEqual( + bytes(request), + b'' + b"foo" + b"", + ) + + request = Targets.modify_target("t1", exclude_hosts=["foo", "bar"]) + + self.assertEqual( + bytes(request), + b'' + b"foo,bar" + b"", + ) + + def test_modify_target_with_ssh_credential_id(self): + request = Targets.modify_target("t1", ssh_credential_id="c1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_target_with_ssh_credential_id_and_port(self): + request = Targets.modify_target( + "t1", ssh_credential_id="c1", ssh_credential_port=22 + ) + + self.assertEqual( + bytes(request), + b'' + b'22' + b"", + ) + + def test_modify_target_with_smb_credential_id(self): + request = Targets.modify_target("t1", smb_credential_id="c1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_target_with_esxi_credential_id(self): + request = Targets.modify_target("t1", esxi_credential_id="c1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_target_with_snmp_credential_id(self): + request = Targets.modify_target("t1", snmp_credential_id="c1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_target_with_alive_tests(self): + request = Targets.modify_target("t1", alive_test=AliveTest.ICMP_PING) + + self.assertEqual( + bytes(request), + b'' + b"ICMP Ping" + b"", + ) + + request = Targets.modify_target("t1", alive_test="icmp ping") + + self.assertEqual( + bytes(request), + b'' + b"ICMP Ping" + b"", + ) + + def test_modify_target_invalid_alive_tests(self): + with self.assertRaises(InvalidArgument): + Targets.modify_target("t1", alive_test="foo") + + def test_modify_target_with_allow_simultaneous_ips(self): + request = Targets.modify_target("t1", allow_simultaneous_ips=True) + + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = Targets.modify_target("t1", allow_simultaneous_ips=False) + + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_target_with_reverse_lookup_only(self): + request = Targets.modify_target("t1", reverse_lookup_only=True) + + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = Targets.modify_target("t1", reverse_lookup_only=False) + + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_target_with_reverse_lookup_unify(self): + request = Targets.modify_target("t1", reverse_lookup_unify=True) + + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = Targets.modify_target("t1", reverse_lookup_unify=False) + + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_target_with_port_list_id(self): + request = Targets.modify_target("t1", port_list_id="pl1") + + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_clone_target(self): + request = Targets.clone_target("t1") + + self.assertEqual( + bytes(request), + b"t1", + ) + + def test_clone_target_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Targets.clone_target(None) + + with self.assertRaises(RequiredArgument): + Targets.clone_target("") + + def test_delete_target(self): + request = Targets.delete_target("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_ultimate(self): + request = Targets.delete_target("t1", ultimate=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Targets.delete_target("t1", ultimate=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_target_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Targets.delete_target(None) + + with self.assertRaises(RequiredArgument): + Targets.delete_target("") + + def test_get_target(self): + request = Targets.get_target("t1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_target_with_tasks(self): + request = Targets.get_target("t1", tasks=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Targets.get_target("t1", tasks=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_target_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Targets.get_target(None) + + with self.assertRaises(RequiredArgument): + Targets.get_target("") + + def test_get_targets(self): + request = Targets.get_targets() + + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_targets_with_filter_string(self): + request = Targets.get_targets(filter_string="foo=bar") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_targets_with_filter_id(self): + request = Targets.get_targets(filter_id="f1") + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_targets_with_trash(self): + request = Targets.get_targets(trash=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Targets.get_targets(trash=False) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_targets_with_tasks(self): + request = Targets.get_targets(tasks=True) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Targets.get_targets(tasks=False) + + self.assertEqual( + bytes(request), + b'', + ) diff --git a/tests/protocols/gmp/requests/v224/test_tasks.py b/tests/protocols/gmp/requests/v224/test_tasks.py new file mode 100644 index 000000000..2e6194e18 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_tasks.py @@ -0,0 +1,720 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import HostsOrdering, Tasks + + +class TasksTestCase(unittest.TestCase): + def test_clone_task(self): + request = Tasks().clone_task("task_id") + self.assertEqual( + bytes(request), + b"task_id", + ) + + def test_clone_task_invalid(self): + with self.assertRaises(RequiredArgument): + Tasks().clone_task(None) + + with self.assertRaises(RequiredArgument): + Tasks().clone_task("") + + def test_create_container_task(self): + request = Tasks().create_container_task("name") + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"", + ) + + def test_create_container_task_with_comment(self): + request = Tasks().create_container_task("name", comment="comment") + self.assertEqual( + bytes(request), + b"" + b"name" + b'' + b"comment" + b"", + ) + + def test_create_task(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"", + ) + + def test_create_task_with_comment(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + comment="comment", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"comment" + b"", + ) + + def test_create_task_with_alterable(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + alterable=True, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"1" + b"", + ) + + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + alterable=False, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"0" + b"", + ) + + def test_create_task_with_hosts_ordering(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + hosts_ordering="random", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"random" + b"", + ) + + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + hosts_ordering=HostsOrdering.RANDOM, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"random" + b"", + ) + + def test_create_task_with_alert_ids(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + alert_ids=["alert_id1", "alert_id2"], + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b'' + b'' + b"", + ) + + def test_create_task_with_schedule_id(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + schedule_id="schedule_id", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b'' + b"", + ) + + def test_create_task_with_scanner_id_and_schedule_periods(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + schedule_id="schedule_id", + schedule_periods=5, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b'' + b"5" + b"", + ) + + def test_create_task_with_scanner_id_and_invalid_schedule_periods(self): + with self.assertRaises(InvalidArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + schedule_id="schedule_id", + schedule_periods=-1, + ) + with self.assertRaises(InvalidArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + schedule_id="schedule_id", + schedule_periods="invalid", + ) + + def test_create_task_with_observers(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + observers=["observer_id1", "observer_id2"], + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"observer_id1,observer_id2" + b"", + ) + + def test_create_task_with_preferences(self): + request = Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + preferences={"key1": "value1", "key2": "value2"}, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"scan" + b'' + b'' + b'' + b"" + b"" + b"key1" + b"value1" + b"" + b"" + b"key2" + b"value2" + b"" + b"" + b"", + ) + + def test_create_task_invalid_hosts_ordering(self): + with self.assertRaises(InvalidArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + hosts_ordering="invalid", + ) + + def test_create_task_missing_name(self): + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "", + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + ) + with self.assertRaises(RequiredArgument): + Tasks().create_task( + None, + target_id="target_id", + config_id="config_id", + scanner_id="scanner_id", + ) + + def test_create_task_missing_target_id(self): + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id="", + config_id="config_id", + scanner_id="scanner_id", + ) + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id=None, + config_id="config_id", + scanner_id="scanner_id", + ) + + def test_create_task_missing_config_id(self): + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="", + scanner_id="scanner_id", + ) + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id=None, + scanner_id="scanner_id", + ) + + def test_create_task_missing_scanner_id(self): + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id="", + ) + with self.assertRaises(RequiredArgument): + Tasks().create_task( + "name", + target_id="target_id", + config_id="config_id", + scanner_id=None, + ) + + def test_delete_task(self): + request = Tasks().delete_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_task_with_ultimate(self): + request = Tasks().delete_task("task_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tasks().delete_task("task_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().delete_task("") + + with self.assertRaises(RequiredArgument): + Tasks().delete_task(None) + + def test_get_tasks(self): + request = Tasks().get_tasks() + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tasks_with_filter_string(self): + request = Tasks().get_tasks(filter_string="filter_string") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tasks_with_filter_id(self): + request = Tasks().get_tasks(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tasks_with_trash(self): + request = Tasks().get_tasks(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tasks().get_tasks(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tasks_with_details(self): + request = Tasks().get_tasks(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tasks().get_tasks(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tasks_with_schedules_only(self): + request = Tasks().get_tasks(schedules_only=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tasks().get_tasks(schedules_only=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_task(self): + request = Tasks().get_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().get_task("") + + with self.assertRaises(RequiredArgument): + Tasks().get_task(None) + + def test_modify_task(self): + request = Tasks().modify_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_task_with_name(self): + request = Tasks().modify_task("task_id", name="name") + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_task_with_config_id(self): + request = Tasks().modify_task("task_id", config_id="config_id") + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_task_with_comment(self): + request = Tasks().modify_task("task_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_task_with_target_id(self): + request = Tasks().modify_task("task_id", target_id="target_id") + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_task_with_alterable(self): + request = Tasks().modify_task("task_id", alterable=True) + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = Tasks().modify_task("task_id", alterable=False) + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) + + def test_modify_task_with_hosts_ordering(self): + request = Tasks().modify_task("task_id", hosts_ordering="random") + self.assertEqual( + bytes(request), + b'' + b"random" + b"", + ) + + request = Tasks().modify_task( + "task_id", hosts_ordering=HostsOrdering.RANDOM + ) + self.assertEqual( + bytes(request), + b'' + b"random" + b"", + ) + + def test_modify_task_with_scanner_id(self): + request = Tasks().modify_task("task_id", scanner_id="scanner_id") + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_task_with_schedule_id(self): + request = Tasks().modify_task("task_id", schedule_id="schedule_id") + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_task_with_schedule_periods(self): + request = Tasks().modify_task("task_id", schedule_periods=5) + self.assertEqual( + bytes(request), + b'' + b"5" + b"", + ) + + def test_modify_task_with_alert_ids(self): + request = Tasks().modify_task( + "task_id", alert_ids=["alert_id1", "alert_id2"] + ) + self.assertEqual( + bytes(request), + b'' + b'' + b'' + b"", + ) + + request = Tasks().modify_task("task_id", alert_ids=[]) + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_task_with_observers(self): + request = Tasks().modify_task( + "task_id", observers=["observer_id1", "observer_id2"] + ) + self.assertEqual( + bytes(request), + b'' + b"observer_id1,observer_id2" + b"", + ) + request = Tasks().modify_task("task_id", observers=[]) + self.assertEqual( + bytes(request), + b'' + b"" + b"", + ) + + def test_modify_task_with_preferences(self): + request = Tasks().modify_task( + "task_id", preferences={"key1": "value1", "key2": "value2"} + ) + self.assertEqual( + bytes(request), + b'' + b"" + b"" + b"key1" + b"value1" + b"" + b"" + b"key2" + b"value2" + b"" + b"" + b"", + ) + + request = Tasks().modify_task("task_id", preferences={}) + self.assertEqual( + bytes(request), + b'' + b"" + b"", + ) + + def test_modify_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().modify_task("") + + with self.assertRaises(RequiredArgument): + Tasks().modify_task(None) + + def test_modify_task_invalid_schedule_periods(self): + with self.assertRaises(InvalidArgument): + Tasks().modify_task("task_id", schedule_periods=-1) + with self.assertRaises(InvalidArgument): + Tasks().modify_task("task_id", schedule_periods="invalid") + + def test_modify_task_invalid_hosts_ordering(self): + with self.assertRaises(InvalidArgument): + Tasks().modify_task("task_id", hosts_ordering="invalid") + + def test_move_task(self): + request = Tasks().move_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_move_task_with_slave_id(self): + request = Tasks().move_task("task_id", slave_id="slave_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_move_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().move_task("") + + with self.assertRaises(RequiredArgument): + Tasks().move_task(None) + + def test_start_task(self): + request = Tasks().start_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_start_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().start_task("") + + with self.assertRaises(RequiredArgument): + Tasks().start_task(None) + + def test_resume_task(self): + request = Tasks().resume_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_resume_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().resume_task("") + + with self.assertRaises(RequiredArgument): + Tasks().resume_task(None) + + def test_stop_task(self): + request = Tasks().stop_task("task_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_stop_task_missing_task_id(self): + with self.assertRaises(RequiredArgument): + Tasks().stop_task("") + + with self.assertRaises(RequiredArgument): + Tasks().stop_task(None) diff --git a/tests/protocols/gmp/requests/v224/test_tickets.py b/tests/protocols/gmp/requests/v224/test_tickets.py new file mode 100644 index 000000000..45bce5e99 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_tickets.py @@ -0,0 +1,247 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import Tickets, TicketStatus + + +class TicketsTestCase(unittest.TestCase): + def test_clone_ticket(self): + request = Tickets.clone_ticket("ticket_id") + self.assertEqual( + bytes(request), + b"ticket_id", + ) + + def test_clone_ticket_missing_ticket_id(self): + with self.assertRaises(RequiredArgument): + Tickets.clone_ticket(None) + + with self.assertRaises(RequiredArgument): + Tickets.clone_ticket("") + + def test_create_ticket(self): + request = Tickets.create_ticket( + result_id="result_id", + assigned_to_user_id="user_id", + note="note", + ) + self.assertEqual( + bytes(request), + b"" + b'' + b'' + b"note" + b"", + ) + + def test_create_ticket_with_comment(self): + request = Tickets.create_ticket( + result_id="result_id", + assigned_to_user_id="user_id", + note="note", + comment="comment", + ) + self.assertEqual( + bytes(request), + b"" + b'' + b'' + b"note" + b"comment" + b"", + ) + + def test_create_ticket_missing_result_id(self): + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id=None, assigned_to_user_id="user_id", note="note" + ) + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id="", assigned_to_user_id="user_id", note="note" + ) + + def test_create_ticket_missing_assigned_to_user_id(self): + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id="result_id", assigned_to_user_id=None, note="note" + ) + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id="result_id", assigned_to_user_id="", note="note" + ) + + def test_create_ticket_missing_note(self): + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id="result_id", assigned_to_user_id="user_id", note=None + ) + + with self.assertRaises(RequiredArgument): + Tickets.create_ticket( + result_id="result_id", assigned_to_user_id="user_id", note="" + ) + + def test_delete_ticket(self): + request = Tickets.delete_ticket("ticket_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_ticket_with_ultimate(self): + request = Tickets.delete_ticket("ticket_id", ultimate=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tickets.delete_ticket("ticket_id", ultimate=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_ticket_missing_ticket_id(self): + with self.assertRaises(RequiredArgument): + Tickets.delete_ticket(None) + + with self.assertRaises(RequiredArgument): + Tickets.delete_ticket("") + + def test_get_tickets(self): + request = Tickets.get_tickets() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_tickets_with_filter_string(self): + request = Tickets.get_tickets(filter_string="filter") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tickets_with_filter_id(self): + request = Tickets.get_tickets(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tickets_with_trash(self): + request = Tickets.get_tickets(trash=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = Tickets.get_tickets(trash=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_ticket(self): + request = Tickets.get_ticket("ticket_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_ticket_missing_ticket_id(self): + with self.assertRaises(RequiredArgument): + Tickets.get_ticket(None) + + with self.assertRaises(RequiredArgument): + Tickets.get_ticket("") + + def test_modify_ticket(self): + request = Tickets.modify_ticket("ticket_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_ticket_with_status_and_note(self): + request = Tickets.modify_ticket( + "ticket_id", status=TicketStatus.FIXED, note="note" + ) + self.assertEqual( + bytes(request), + b'' + b"Fixed" + b"note" + b"", + ) + + request = Tickets.modify_ticket( + "ticket_id", status="fixed", note="note" + ) + self.assertEqual( + bytes(request), + b'' + b"Fixed" + b"note" + b"", + ) + + def test_modify_ticket_with_assigned_to_user_id(self): + request = Tickets.modify_ticket( + "ticket_id", assigned_to_user_id="user_id" + ) + self.assertEqual( + bytes(request), + b'' + b'' + b"", + ) + + def test_modify_ticket_with_comment(self): + request = Tickets.modify_ticket("ticket_id", comment="comment") + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_ticket_missing_ticket_id(self): + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket(None) + + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket("") + + def test_modify_ticket_with_status_missing_note(self): + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket("ticket_id", status=TicketStatus.FIXED) + + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket( + "ticket_id", status=TicketStatus.FIXED, note=None + ) + + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket( + "ticket_id", status=TicketStatus.FIXED, note="" + ) + + def test_modify_ticket_with_note_missing_status(self): + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket("ticket_id", note="note") + + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket("ticket_id", note="note", status=None) + + with self.assertRaises(RequiredArgument): + Tickets.modify_ticket("ticket_id", note="note", status="") + + def test_modify_ticket_invalid_status(self): + with self.assertRaises(InvalidArgument): + Tickets.modify_ticket("ticket_id", note="note", status="invalid") diff --git a/tests/protocols/gmp/requests/v224/test_tls_certificates.py b/tests/protocols/gmp/requests/v224/test_tls_certificates.py new file mode 100644 index 000000000..33968fbdd --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_tls_certificates.py @@ -0,0 +1,246 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import TLSCertificates + + +class TLSCertificatesTestCase(unittest.TestCase): + def test_clone_tls_certificate(self): + request = TLSCertificates.clone_tls_certificate("tls_certificate_id") + self.assertEqual( + bytes(request), + b"" + b"tls_certificate_id" + b"", + ) + + def test_clone_tls_certificate_missing_tls_certificate_id(self): + with self.assertRaises(RequiredArgument): + TLSCertificates.clone_tls_certificate(None) + + with self.assertRaises(RequiredArgument): + TLSCertificates.clone_tls_certificate("") + + def test_create_tls_certificate(self): + request = TLSCertificates.create_tls_certificate( + name="name", + certificate="certificate", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"certificate" + b"", + ) + + def test_create_tls_certificate_with_comment(self): + request = TLSCertificates.create_tls_certificate( + name="name", + certificate="certificate", + comment="comment", + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"certificate" + b"comment" + b"", + ) + + def test_create_tls_certificate_with_trust(self): + request = TLSCertificates.create_tls_certificate( + name="name", + certificate="certificate", + trust=True, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"certificate" + b"1" + b"", + ) + + request = TLSCertificates.create_tls_certificate( + name="name", + certificate="certificate", + trust=False, + ) + self.assertEqual( + bytes(request), + b"" + b"name" + b"certificate" + b"0" + b"", + ) + + def test_create_tls_certificate_missing_name(self): + with self.assertRaises(RequiredArgument): + TLSCertificates.create_tls_certificate( + name=None, + certificate="certificate", + ) + + with self.assertRaises(RequiredArgument): + TLSCertificates.create_tls_certificate( + name="", + certificate="certificate", + ) + + def test_create_tls_certificate_missing_certificate(self): + with self.assertRaises(RequiredArgument): + TLSCertificates.create_tls_certificate( + name="name", + certificate=None, + ) + + with self.assertRaises(RequiredArgument): + TLSCertificates.create_tls_certificate( + name="name", + certificate="", + ) + + def test_delete_tls_certificate(self): + request = TLSCertificates.delete_tls_certificate("tls_certificate_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_delete_tls_certificate_missing_tls_certificate_id(self): + with self.assertRaises(RequiredArgument): + TLSCertificates.delete_tls_certificate(None) + + with self.assertRaises(RequiredArgument): + TLSCertificates.delete_tls_certificate("") + + def test_get_tls_certificates(self): + request = TLSCertificates.get_tls_certificates() + self.assertEqual( + bytes(request), + b"", + ) + + def test_get_tls_certificates_with_filter_string(self): + request = TLSCertificates.get_tls_certificates( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tls_certificates_with_filter_id(self): + request = TLSCertificates.get_tls_certificates(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tls_certificates_with_details(self): + request = TLSCertificates.get_tls_certificates(details=True) + self.assertEqual( + bytes(request), + b'', + ) + + request = TLSCertificates.get_tls_certificates(details=False) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tls_certificates_with_include_certificate_data(self): + request = TLSCertificates.get_tls_certificates( + include_certificate_data=True + ) + self.assertEqual( + bytes(request), + b'', + ) + + request = TLSCertificates.get_tls_certificates( + include_certificate_data=False + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tls_certificate(self): + request = TLSCertificates.get_tls_certificate("tls_certificate_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_tls_certificate_missing_tls_certificate_id(self): + with self.assertRaises(RequiredArgument): + TLSCertificates.get_tls_certificate(None) + + with self.assertRaises(RequiredArgument): + TLSCertificates.get_tls_certificate("") + + def test_modify_tls_certificate(self): + request = TLSCertificates.modify_tls_certificate( + "tls_certificate_id", + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_tls_certificate_with_name(self): + request = TLSCertificates.modify_tls_certificate( + "tls_certificate_id", + name="name", + ) + self.assertEqual( + bytes(request), + b'' + b"name" + b"", + ) + + def test_modify_tls_certificate_with_comment(self): + request = TLSCertificates.modify_tls_certificate( + "tls_certificate_id", + comment="comment", + ) + self.assertEqual( + bytes(request), + b'' + b"comment" + b"", + ) + + def test_modify_tls_certificate_with_trust(self): + request = TLSCertificates.modify_tls_certificate( + "tls_certificate_id", + trust=True, + ) + self.assertEqual( + bytes(request), + b'' + b"1" + b"", + ) + + request = TLSCertificates.modify_tls_certificate( + "tls_certificate_id", + trust=False, + ) + self.assertEqual( + bytes(request), + b'' + b"0" + b"", + ) diff --git a/tests/protocols/gmp/requests/v224/test_trashcan.py b/tests/protocols/gmp/requests/v224/test_trashcan.py new file mode 100644 index 000000000..90325f4f4 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_trashcan.py @@ -0,0 +1,24 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import TrashCan + + +class TrashCanTestCase(unittest.TestCase): + def test_empty_trashcan(self): + request = TrashCan.empty_trashcan() + + self.assertEqual(bytes(request), b"") + + def test_restore_from_trashcan(self): + request = TrashCan.restore_from_trashcan("1") + + self.assertEqual(bytes(request), b'') + + def test_restore_from_trashcan_with_empty_id(self): + with self.assertRaises(RequiredArgument): + TrashCan.restore_from_trashcan("") diff --git a/tests/protocols/gmp/requests/v224/test_user_settings.py b/tests/protocols/gmp/requests/v224/test_user_settings.py new file mode 100644 index 000000000..77c41ac54 --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_user_settings.py @@ -0,0 +1,74 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import UserSettings + + +class UserSettingsTestCase(unittest.TestCase): + def test_get_user_setting(self): + request = UserSettings.get_user_setting("id") + + self.assertEqual(bytes(request), b'') + + def test_get_user_setting_missing_setting_id(self): + with self.assertRaises(RequiredArgument): + UserSettings.get_user_setting(setting_id=None) + + with self.assertRaises(RequiredArgument): + UserSettings.get_user_setting("") + + def test_get_user_settings(self): + request = UserSettings.get_user_settings() + + self.assertEqual(bytes(request), b"") + + def test_get_user_settings_with_filter_string(self): + request = UserSettings.get_user_settings(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_modify_user_setting(self): + request = UserSettings.modify_user_setting( + setting_id="id", value="value" + ) + + self.assertEqual( + bytes(request), + b'dmFsdWU=', + ) + + request = UserSettings.modify_user_setting(name="name", value="value") + + self.assertEqual( + bytes(request), + b"namedmFsdWU=", + ) + + request = UserSettings.modify_user_setting(name="name", value="") + + self.assertEqual( + bytes(request), + b"name", + ) + + def test_modify_user_setting_missing_setting_id(self): + with self.assertRaises(RequiredArgument): + UserSettings.modify_user_setting(setting_id=None, value="value") + + with self.assertRaises(RequiredArgument): + UserSettings.modify_user_setting(setting_id="", value="value") + + def test_modify_setting_missing_name(self): + with self.assertRaises(RequiredArgument): + UserSettings.modify_user_setting(name=None, value="value") + + with self.assertRaises(RequiredArgument): + UserSettings.modify_user_setting(name="", value="value") + + def test_modify_user_setting_missing_value(self): + with self.assertRaises(RequiredArgument): + UserSettings.modify_user_setting(setting_id="id", value=None) diff --git a/tests/protocols/gmp/requests/v224/test_users.py b/tests/protocols/gmp/requests/v224/test_users.py new file mode 100644 index 000000000..3182680fb --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_users.py @@ -0,0 +1,266 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import UserAuthType, Users + + +class UsersTestCase(unittest.TestCase): + def test_get_users(self): + request = Users().get_users() + + self.assertEqual(bytes(request), b"") + + def test_get_users_with_filter_string(self): + request = Users().get_users(filter_string="foo=bar") + + self.assertEqual(bytes(request), b'') + + def test_get_users_with_filter_id(self): + request = Users().get_users(filter_id="f1") + + self.assertEqual(bytes(request), b'') + + def test_create_user(self): + request = Users().create_user(name="foo") + + self.assertEqual( + bytes(request), b"foo" + ) + + def test_create_user_with_password(self): + request = Users().create_user(name="foo", password="bar") + + self.assertEqual( + bytes(request), + b"foobar", + ) + + def test_create_user_with_hosts(self): + request = Users().create_user( + name="foo", hosts=["h1", "h2"], hosts_allow=True + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'h1,h2' + b"", + ) + + request = Users().create_user( + name="foo", hosts=["h1", "h2"], hosts_allow=False + ) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'h1,h2' + b"", + ) + + def test_create_user_with_role_ids(self): + request = Users().create_user(name="foo", role_ids=["r1", "r2"]) + + self.assertEqual( + bytes(request), + b"" + b"foo" + b'' + b'' + b"", + ) + + def test_create_user_missing_name(self): + with self.assertRaises(RequiredArgument): + Users().create_user("") + + with self.assertRaises(RequiredArgument): + Users().create_user(None) + + def test_modify_user(self): + request = Users().modify_user(user_id="u1") + + self.assertEqual(bytes(request), b'') + + def test_modify_user_missing_user_id(self): + with self.assertRaises(RequiredArgument): + Users().modify_user(user_id=None) + + with self.assertRaises(RequiredArgument): + Users().modify_user(user_id="") + + def test_modify_user_with_new_name(self): + request = Users().modify_user(user_id="u1", name="foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_user_with_new_comment(self): + request = Users().modify_user(user_id="u1", comment="foo") + + self.assertEqual( + bytes(request), + b'foo', + ) + + def test_modify_user_with_role_ids(self): + request = Users().modify_user(user_id="u1", role_ids=[]) + + self.assertEqual(bytes(request), b'') + + request = Users().modify_user(user_id="u1", role_ids=["r1"]) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Users().modify_user(user_id="u1", role_ids=["r1", "r2"]) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_user_with_group_ids(self): + request = Users().modify_user(user_id="u1", group_ids=[]) + + self.assertEqual(bytes(request), b'') + + request = Users().modify_user(user_id="u1", group_ids=["g1"]) + + self.assertEqual( + bytes(request), + b'', + ) + + request = Users().modify_user(user_id="u1", group_ids=["g1", "g2"]) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_modify_user_with_password(self): + request = Users().modify_user(user_id="u1", password="bar") + + self.assertEqual( + bytes(request), + b'bar', + ) + + def test_modify_user_with_auth_source(self): + request = Users().modify_user( + user_id="u1", auth_source=UserAuthType.LDAP_CONNECT + ) + + self.assertEqual( + bytes(request), + b'' + b"ldap_connect" + b"", + ) + + request = Users().modify_user(user_id="u1", auth_source="ldap_connect") + + self.assertEqual( + bytes(request), + b'' + b"ldap_connect" + b"", + ) + + def test_modify_user_invalid_auth_source(self): + with self.assertRaises(InvalidArgument): + Users().modify_user(user_id="u1", auth_source="foo") + + def test_modify_user_with_hosts(self): + request = Users().modify_user( + user_id="u1", hosts=["h1", "h2"], hosts_allow=True + ) + + self.assertEqual( + bytes(request), + b'' + b'h1,h2' + b"", + ) + + request = Users().modify_user( + user_id="u1", hosts=["h1", "h2"], hosts_allow=False + ) + + self.assertEqual( + bytes(request), + b'' + b'h1,h2' + b"", + ) + + def test_clone_user(self): + request = Users().clone_user(user_id="u1") + + self.assertEqual( + bytes(request), b"u1" + ) + + def test_clone_user_missing_user_id(self): + with self.assertRaises(RequiredArgument): + Users().clone_user(user_id=None) + + with self.assertRaises(RequiredArgument): + Users().clone_user(user_id="") + + def test_delete_user_with_user_id(self): + request = Users().delete_user("u1") + + self.assertEqual(bytes(request), b'') + + def test_delete_user_with_name(self): + request = Users().delete_user(name="foo") + + self.assertEqual(bytes(request), b'') + + def test_delete_user_with_inheritor_id(self): + request = Users().delete_user("u1", inheritor_id="u2") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_user_with_inheritor_name(self): + request = Users().delete_user("u1", inheritor_name="foo") + + self.assertEqual( + bytes(request), b'' + ) + + def test_delete_user_missing_user_id_and_name(self): + with self.assertRaises(RequiredArgument): + Users().delete_user(None) + + with self.assertRaises(RequiredArgument): + Users().delete_user("") + + with self.assertRaises(RequiredArgument): + Users().delete_user(user_id="", name="") + + def test_get_user(self): + request = Users().get_user("u1") + + self.assertEqual(bytes(request), b'') + + def test_get_user_missing_user_id(self): + with self.assertRaises(RequiredArgument): + Users().get_user(user_id=None) + + with self.assertRaises(RequiredArgument): + Users().get_user("") diff --git a/tests/protocols/gmp/requests/v224/test_vulnerabilities.py b/tests/protocols/gmp/requests/v224/test_vulnerabilities.py new file mode 100644 index 000000000..de6dac9da --- /dev/null +++ b/tests/protocols/gmp/requests/v224/test_vulnerabilities.py @@ -0,0 +1,44 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import RequiredArgument +from gvm.protocols.gmp.requests.v224 import Vulnerabilities + + +class VulnerabilitiesTestCase(unittest.TestCase): + def test_get_vulnerabilities(self): + request = Vulnerabilities.get_vulnerabilities() + self.assertEqual(bytes(request), b"") + + def test_get_vulnerabilities_with_filter_string(self): + request = Vulnerabilities.get_vulnerabilities( + filter_string="filter_string" + ) + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_vulnerabilities_with_filter_id(self): + request = Vulnerabilities.get_vulnerabilities(filter_id="filter_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_vulnerability(self): + request = Vulnerabilities.get_vulnerability("vulnerability_id") + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_vulnerability_missing_vulnerability_id(self): + with self.assertRaises(RequiredArgument): + Vulnerabilities.get_vulnerability(None) + + with self.assertRaises(RequiredArgument): + Vulnerabilities.get_vulnerability("") diff --git a/tests/protocols/gmp/requests/v225/__init__.py b/tests/protocols/gmp/requests/v225/__init__.py new file mode 100644 index 000000000..5197e3be9 --- /dev/null +++ b/tests/protocols/gmp/requests/v225/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later diff --git a/tests/protocols/gmp/requests/v225/test_resource_names.py b/tests/protocols/gmp/requests/v225/test_resource_names.py new file mode 100644 index 000000000..0b325ea03 --- /dev/null +++ b/tests/protocols/gmp/requests/v225/test_resource_names.py @@ -0,0 +1,417 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.protocols.gmp.requests.v225 import ResourceNames, ResourceType + + +class ResourceNamesTestCase(unittest.TestCase): + def test_get_resource_names(self) -> None: + request = ResourceNames.get_resource_names(ResourceType.ALERT) + + self.assertIsInstance(request, Request) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.CERT_BUND_ADV) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.CONFIG) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names( + resource_type=ResourceType.CPE + ) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.CREDENTIAL) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.CVE) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.DFN_CERT_ADV) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.FILTER) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.GROUP) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.HOST) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.NOTE) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.NVT) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.OS) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.OVERRIDE) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.PERMISSION) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.PORT_LIST) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.REPORT_FORMAT) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.REPORT) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.RESULT) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.ROLE) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.SCANNER) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.SCHEDULE) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.TARGET) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.TASK) + + self.assertEqual(bytes(request), b'') + + request = ResourceNames.get_resource_names(ResourceType.TLS_CERTIFICATE) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_names(ResourceType.USER) + + self.assertEqual(bytes(request), b'') + + def test_get_resource_names_missing_resource_type(self) -> None: + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_names(resource_type=None) # type: ignore + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_names(resource_type="") + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_names("") + + def test_get_resource_names_invalid_resource_type(self) -> None: + with self.assertRaises(InvalidArgument): + ResourceNames.get_resource_names(resource_type="foo") + + def test_get_resource_names_with_filter_string(self) -> None: + request = ResourceNames.get_resource_names( + ResourceType.CPE, filter_string="foo=bar" + ) + + self.assertEqual( + bytes(request), b'' + ) + + def test_get_resource_name(self): + request = ResourceNames.get_resource_name( + resource_type=ResourceType.ALERT, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.CERT_BUND_ADV, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.CONFIG, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.CPE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.CREDENTIAL, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.CVE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.DFN_CERT_ADV, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.FILTER, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.GROUP, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.HOST, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.NOTE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.NVT, resource_id="i1" + ) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.OS, resource_id="i1" + ) + + self.assertEqual( + bytes(request), b'' + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.PERMISSION, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.PORT_LIST, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.REPORT_FORMAT, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.REPORT, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.RESULT, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.ROLE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.SCANNER, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.SCHEDULE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.TARGET, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.TASK, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.TLS_CERTIFICATE, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + request = ResourceNames.get_resource_name( + resource_type=ResourceType.USER, resource_id="i1" + ) + + self.assertEqual( + bytes(request), + b'', + ) + + def test_get_resource_name_missing_resource_type(self): + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name( + resource_id="i1", resource_type=None + ) + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name(resource_id="i1", resource_type="") + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name("i1", "") + + def test_get_resource_name_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + ResourceNames.get_resource_name( + resource_id="i1", resource_type="foo" + ) + + def test_get_resource_name_missing_resource_id(self): + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name( + resource_id="", resource_type=ResourceType.CPE + ) + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name("", resource_type=ResourceType.CPE) + + with self.assertRaises(RequiredArgument): + ResourceNames.get_resource_name( + resource_id=None, resource_type=ResourceType.CPE + ) diff --git a/tests/protocols/gmp/test_context_manager.py b/tests/protocols/gmp/test_context_manager.py index ef7cc99d1..8a8661036 100644 --- a/tests/protocols/gmp/test_context_manager.py +++ b/tests/protocols/gmp/test_context_manager.py @@ -8,10 +8,8 @@ from gvm.errors import GvmError from gvm.protocols.gmp import Gmp -from gvm.protocols.gmpv208 import Gmp as Gmpv208 -from gvm.protocols.gmpv214 import Gmp as Gmpv214 -from gvm.protocols.gmpv224 import Gmp as Gmpv224 -from gvm.protocols.gmpv225 import Gmp as Gmpv225 +from gvm.protocols.gmp._gmp224 import GMPv224 +from gvm.protocols.gmp._gmp225 import GMPv225 from tests.protocols import GmpTestCase @@ -20,9 +18,9 @@ class GmpContextManagerTestCase(GmpTestCase): def test_select_gmpv7(self): self.connection.read.return_value( - '' - "7.0" - "" + b'' + b"7.0" + b"" ) with self.assertRaises(GvmError): @@ -31,9 +29,9 @@ def test_select_gmpv7(self): def test_select_gmpv8(self): self.connection.read.return_value( - '' - "8.0" - "" + b'' + b"8.0" + b"" ) with self.assertRaises(GvmError): @@ -42,9 +40,9 @@ def test_select_gmpv8(self): def test_select_gmpv9(self): self.connection.read.return_value( - '' - "9.0" - "" + b'' + b"9.0" + b"" ) with self.assertRaises(GvmError): @@ -53,53 +51,52 @@ def test_select_gmpv9(self): def test_select_gmpv208(self): self.connection.read.return_value( - '' - "20.08" - "" + b'' + b"20.08" + b"" ) - - with self.gmp as gmp: - self.assertEqual(gmp.get_protocol_version(), (20, 8)) - self.assertIsInstance(gmp, Gmpv208) + with self.assertRaises(GvmError): + with self.gmp: + pass def test_select_gmpv214(self): self.connection.read.return_value( - '' - "21.04" - "" + b'' + b"21.04" + b"" ) - with self.gmp as gmp: - self.assertEqual(gmp.get_protocol_version(), (21, 4)) - self.assertIsInstance(gmp, Gmpv214) + with self.assertRaises(GvmError): + with self.gmp: + pass def test_select_gmpv224(self): self.connection.read.return_value( - '' - "22.04" - "" + b'' + b"22.04" + b"" ) with self.gmp as gmp: self.assertEqual(gmp.get_protocol_version(), (22, 4)) - self.assertIsInstance(gmp, Gmpv224) + self.assertIsInstance(gmp, GMPv224) def test_select_gmpv225(self): self.connection.read.return_value( - '' - "22.05" - "" + b'' + b"22.05" + b"" ) with self.gmp as gmp: self.assertEqual(gmp.get_protocol_version(), (22, 5)) - self.assertIsInstance(gmp, Gmpv225) + self.assertIsInstance(gmp, GMPv225) def test_unknown_protocol(self): self.connection.read.return_value( - '' - "1.0" - "" + b'' + b"1.0" + b"" ) with self.assertRaises(GvmError): @@ -108,9 +105,9 @@ def test_unknown_protocol(self): def test_missing_version_in_response(self): self.connection.read.return_value( - '' - "bar" - "" + b'' + b"bar" + b"" ) with self.assertRaises(GvmError): @@ -118,18 +115,18 @@ def test_missing_version_in_response(self): pass def test_invalid_response(self): - self.connection.read.return_value("") + self.connection.read.return_value(b"") with self.assertRaises(GvmError): with self.gmp: pass - @patch("gvm.protocols.gmp.Gmpv214") + @patch("gvm.protocols.gmp._gmp.GMPv224", autospec=True) def test_connect_disconnect(self, gmp_mock: MagicMock): self.connection.read.return_value( - '' - "21.04" - "" + b'' + b"22.04" + b"" ) with self.gmp: diff --git a/tests/protocols/gmpv208/__init__.py b/tests/protocols/gmpv208/__init__.py deleted file mode 100644 index ae92608b6..000000000 --- a/tests/protocols/gmpv208/__init__.py +++ /dev/null @@ -1,12 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.protocols.gmpv208 import Gmp - -from .. import GmpTestCase - - -class Gmpv208TestCase(GmpTestCase): - gmp_class = Gmp diff --git a/tests/protocols/gmpv208/entities/__init__.py b/tests/protocols/gmpv208/entities/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/tests/protocols/gmpv208/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv208/entities/notes/__init__.py b/tests/protocols/gmpv208/entities/notes/__init__.py deleted file mode 100644 index 7fb62081e..000000000 --- a/tests/protocols/gmpv208/entities/notes/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_note import GmpCloneNoteTestMixin -from .test_create_note import GmpCreateNoteTestMixin -from .test_delete_note import GmpDeleteNoteTestMixin -from .test_get_note import GmpGetNoteTestMixin -from .test_get_notes import GmpGetNotesTestMixin -from .test_modify_note import GmpModifyNoteTestMixin - -__all__ = ( - "GmpCloneNoteTestMixin", - "GmpCreateNoteTestMixin", - "GmpDeleteNoteTestMixin", - "GmpGetNoteTestMixin", - "GmpGetNotesTestMixin", - "GmpModifyNoteTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/notes/test_create_note.py b/tests/protocols/gmpv208/entities/notes/test_create_note.py deleted file mode 100644 index 8dff99202..000000000 --- a/tests/protocols/gmpv208/entities/notes/test_create_note.py +++ /dev/null @@ -1,175 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import SeverityLevel - - -class GmpCreateNoteTestMixin: - def test_create_note(self): - self.gmp.create_note("foo", nvt_oid="oid1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_note_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_note(None, "od1") - - with self.assertRaises(RequiredArgument): - self.gmp.create_note("", "oid1") - - def test_create_note_missing_nvt_oid(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_note("foo", None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_note("foo", "") - - def test_create_note_with_hosts(self): - self.gmp.create_note("foo", nvt_oid="oid1", hosts=[]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", hosts=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" - ) - - def test_create_note_with_port(self): - self.gmp.create_note("foo", nvt_oid="oid1", port="666/tcp") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "666/tcp" - "" - ) - - def test_create_note_with_result_id(self): - self.gmp.create_note("foo", nvt_oid="oid1", result_id="r1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_note_with_task_id(self): - self.gmp.create_note("foo", nvt_oid="oid1", task_id="t1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_note_with_severity(self): - self.gmp.create_note("foo", nvt_oid="oid1", severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_note_with_threat(self): - self.gmp.create_note("foo", nvt_oid="oid1", threat=SeverityLevel.HIGH) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "High" - "" - ) - - def test_create_note_invalid_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_note("foo", nvt_oid="oid1", threat="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_note("foo", nvt_oid="oid1", threat="foo") - - def test_create_note_with_days_active(self): - self.gmp.create_note("foo", nvt_oid="oid1", days_active=0) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", days_active=-1) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", days_active=3600) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" - ) - - def test_create_note_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.create_note(text="foo", nvt_oid="oid1", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.create_note(text="foo", nvt_oid="oid1", port="tcp/123") diff --git a/tests/protocols/gmpv208/entities/notes/test_modify_note.py b/tests/protocols/gmpv208/entities/notes/test_modify_note.py deleted file mode 100644 index 740fac436..000000000 --- a/tests/protocols/gmpv208/entities/notes/test_modify_note.py +++ /dev/null @@ -1,169 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import SeverityLevel - - -class GmpModifyNoteTestMixin: - def test_modify_note(self): - self.gmp.modify_note(note_id="n1", text="foo") - - self.connection.send.has_been_called_with( - 'foo' - ) - - def test_modify_note_missing_note_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id=None, text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="", text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note("", text="foo") - - def test_modify_note_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="n1", text="") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="n1", text=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note("n1", "") - - def test_modify_note_with_days_active(self): - self.gmp.modify_note(note_id="n1", text="foo", days_active=0) - - self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", days_active=-1) - - self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", days_active=600) - - self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" - ) - - def test_modify_note_with_port(self): - self.gmp.modify_note(note_id="n1", text="foo", port="123/tcp") - - self.connection.send.has_been_called_with( - '' - "foo" - "123/tcp" - "" - ) - - def test_modify_note_with_hosts(self): - self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" - ) - - def test_modify_note_with_result_id(self): - self.gmp.modify_note(note_id="n1", text="foo", result_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_note_with_task_id(self): - self.gmp.modify_note(note_id="n1", text="foo", task_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_note_with_severity(self): - self.gmp.modify_note(note_id="n1", text="foo", severity="5.5") - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_note_with_threat(self): - self.gmp.modify_note( - note_id="n1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "High" - "" - ) - - def test_modify_note_invalid_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_note(note_id="n1", text="foo", threat="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_note(note_id="n1", text="foo", threat="foo") - - def test_modify_note_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.modify_note(note_id="o1", text="foo", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.modify_note(note_id="o1", text="foo", port="tcp/123") diff --git a/tests/protocols/gmpv208/entities/overrides/__init__.py b/tests/protocols/gmpv208/entities/overrides/__init__.py deleted file mode 100644 index 3dd4e1978..000000000 --- a/tests/protocols/gmpv208/entities/overrides/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_override import GmpCloneOverrideTestMixin -from .test_create_override import GmpCreateOverrideTestMixin -from .test_delete_override import GmpDeleteOverrideTestMixin -from .test_get_override import GmpGetOverrideTestMixin -from .test_get_overrides import GmpGetOverridesTestMixin -from .test_modify_override import GmpModifyOverrideTestMixin - -__all__ = ( - "GmpCloneOverrideTestMixin", - "GmpCreateOverrideTestMixin", - "GmpDeleteOverrideTestMixin", - "GmpGetOverrideTestMixin", - "GmpGetOverridesTestMixin", - "GmpModifyOverrideTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/overrides/test_create_override.py b/tests/protocols/gmpv208/entities/overrides/test_create_override.py deleted file mode 100644 index b91b4a320..000000000 --- a/tests/protocols/gmpv208/entities/overrides/test_create_override.py +++ /dev/null @@ -1,230 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import SeverityLevel - - -class GmpCreateOverrideTestMixin: - def test_create_override(self): - self.gmp.create_override("foo", nvt_oid="oid1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_override_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_override(None, "od1") - - with self.assertRaises(RequiredArgument): - self.gmp.create_override("", "oid1") - - def test_create_override_missing_nvt_oid(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_override("foo", None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_override("foo", "") - - def test_create_override_with_hosts(self): - self.gmp.create_override("foo", nvt_oid="oid1", hosts=[]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", hosts=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" - ) - - def test_create_override_with_port(self): - self.gmp.create_override("foo", nvt_oid="oid1", port="666/tcp") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "666/tcp" - "" - ) - - def test_create_override_with_result_id(self): - self.gmp.create_override("foo", nvt_oid="oid1", result_id="r1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_override_with_task_id(self): - self.gmp.create_override("foo", nvt_oid="oid1", task_id="t1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_override_with_severity(self): - self.gmp.create_override("foo", nvt_oid="oid1", severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_override_with_new_severity(self): - self.gmp.create_override("foo", nvt_oid="oid1", new_severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", new_severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override( - "foo", nvt_oid="oid1", new_severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_override_with_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "High" - "" - ) - - def test_create_override_invalid_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_override("foo", nvt_oid="oid1", threat="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_override("foo", nvt_oid="oid1", threat="foo") - - def test_create_override_with_new_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "High" - "" - ) - - def test_create_override_invalid_new_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_override("foo", nvt_oid="oid1", new_threat="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_override("foo", nvt_oid="oid1", new_threat="foo") - - def test_create_override_with_days_active(self): - self.gmp.create_override("foo", nvt_oid="oid1", days_active=0) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", days_active=-1) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", days_active=3600) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" - ) - - def test_create_override_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.create_override(text="foo", nvt_oid="oid1", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.create_override(text="foo", nvt_oid="oid1", port="tcp/123") diff --git a/tests/protocols/gmpv208/entities/overrides/test_modify_override.py b/tests/protocols/gmpv208/entities/overrides/test_modify_override.py deleted file mode 100644 index 4aa0dfc7c..000000000 --- a/tests/protocols/gmpv208/entities/overrides/test_modify_override.py +++ /dev/null @@ -1,232 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import SeverityLevel - - -class GmpModifyOverrideTestMixin: - def test_modify_override(self): - self.gmp.modify_override(override_id="o1", text="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_override_missing_override_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id=None, text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="", text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override("", text="foo") - - def test_modify_override_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="o1", text="") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="o1", text=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override("o1", "") - - def test_modify_override_with_days_active(self): - self.gmp.modify_override(override_id="o1", text="foo", days_active=0) - - self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", days_active=-1) - - self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", days_active=600) - - self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" - ) - - def test_modify_override_with_port(self): - self.gmp.modify_override(override_id="o1", text="foo", port="123/udp") - - self.connection.send.has_been_called_with( - '' - "foo" - "123/udp" - "" - ) - - def test_modify_override_with_hosts(self): - self.gmp.modify_override(override_id="o1", text="foo", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", hosts=["foo", "bar"] - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" - ) - - def test_modify_override_with_result_id(self): - self.gmp.modify_override(override_id="o1", text="foo", result_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_override_with_task_id(self): - self.gmp.modify_override(override_id="o1", text="foo", task_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_override_with_severity(self): - self.gmp.modify_override(override_id="o1", text="foo", severity="5.5") - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_override_with_new_severity(self): - self.gmp.modify_override( - override_id="o1", text="foo", new_severity="5.5" - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", new_severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", new_severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_override_with_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "High" - "" - ) - - def test_modify_override_invalid_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_override(override_id="o1", text="foo", threat="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_override(override_id="o1", text="foo", threat="foo") - - def test_modify_override_with_new_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "High" - "" - ) - - def test_modify_override_invalid_new_threat(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_override( - override_id="o1", text="foo", new_threat="" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_override( - override_id="o1", text="foo", new_threat="foo" - ) - - def test_modify_override_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.modify_override(override_id="o1", text="foo", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.modify_override( - override_id="o1", text="foo", port="tcp/123" - ) diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_family_selection.py b/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_family_selection.py deleted file mode 100644 index a697db0b5..000000000 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_family_selection.py +++ /dev/null @@ -1,220 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument - - -class GmpModifyPolicySetFamilySelectionTestMixin: - def test_modify_policy_set_family_selection(self): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", True, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=(("foo", True, True), ("bar", True, True)) - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "bar" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_policy_set_family_selection( - policy_id="c1", - families=[("foo", True, False), ("bar", False, True)], - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "0" - "1" - "" - "" - "bar" - "1" - "0" - "" - "" - "" - ) - - def test_modify_policy_set_family_selection_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_policy_set_family_selection( - policy_id=None, families=[("foo", True, True)] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_policy_set_family_selection( - policy_id="", families=[("foo", True, True)] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_policy_set_family_selection( - "", [("foo", True, True)] - ) - - def test_modify_policy_set_family_selection_invalid_families(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=None - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families="" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection("c1", "") - - def test_modify_policy_set_family_selection_with_auto_add_new_families( - self, - ): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", - families=[("foo", True, True)], - auto_add_new_families=True, - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_policy_set_family_selection( - policy_id="c1", - families=[("foo", True, True)], - auto_add_new_families=False, - ) - - self.connection.send.has_been_called_with( - '' - "" - "0" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - def test_modify_policy_set_family_selection_with_auto_add_new_nvts(self): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", True, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", False, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "" - ) - - self.gmp.modify_policy_set_family_selection( - policy_id="c1", - families=[("foo", False, True), ("bar", True, False)], - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "bar" - "0" - "1" - "" - "" - "" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", "False", "True")] - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", True, None)] - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo", "True", False)] - ) - - with self.assertRaises(InvalidArgument): - self.gmp.modify_policy_set_family_selection( - policy_id="c1", families=[("foo",)] - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/__init__.py b/tests/protocols/gmpv208/entities/scan_configs/__init__.py deleted file mode 100644 index e544d15fd..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/__init__.py +++ /dev/null @@ -1,58 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_scan_config import GmpCloneScanConfigTestMixin -from .test_create_scan_config import GmpCreateScanConfigTestMixin -from .test_create_scan_config_from_osp_scanner import ( - GmpCreateScanConfigFromOSPScannerTestMixin, -) -from .test_delete_scan_config import GmpDeleteScanConfigTestMixin -from .test_get_scan_config import GmpGetScanConfigTestMixin -from .test_get_scan_config_preference import GmpGetScanConfigPreferenceTestMixin -from .test_get_scan_config_preferences import ( - GmpGetScanConfigPreferencesTestMixin, -) -from .test_get_scan_configs import GmpGetScanConfigsTestMixin -from .test_import_scan_config import GmpImportScanConfigTestMixin -from .test_modify_scan_config import GmpModifyScanConfigTestMixin -from .test_modify_scan_config_set_comment import ( - GmpModifyScanConfigSetCommentTestMixin, -) -from .test_modify_scan_config_set_family_selection import ( - GmpModifyScanConfigSetFamilySelectionTestMixin, -) -from .test_modify_scan_config_set_name import ( - GmpModifyScanConfigSetNameTestMixin, -) -from .test_modify_scan_config_set_nvt_preference import ( - GmpModifyScanConfigSetNvtPreferenceTestMixin, -) -from .test_modify_scan_config_set_nvt_selection import ( - GmpModifyScanConfigSetNvtSelectionTestMixin, -) -from .test_modify_scan_config_set_scanner_preference import ( - GmpModifyScanConfigSetScannerPreferenceTestMixin, -) -from .test_sync_scan_config import GmpSyncScanConfigTestMixin - -__all__ = ( - "GmpCloneScanConfigTestMixin", - "GmpCreateScanConfigTestMixin", - "GmpCreateScanConfigFromOSPScannerTestMixin", - "GmpDeleteScanConfigTestMixin", - "GmpGetScanConfigTestMixin", - "GmpGetScanConfigPreferenceTestMixin", - "GmpGetScanConfigPreferencesTestMixin", - "GmpGetScanConfigsTestMixin", - "GmpImportScanConfigTestMixin", - "GmpModifyScanConfigTestMixin", - "GmpModifyScanConfigSetCommentTestMixin", - "GmpModifyScanConfigSetFamilySelectionTestMixin", - "GmpModifyScanConfigSetNameTestMixin", - "GmpModifyScanConfigSetNvtPreferenceTestMixin", - "GmpModifyScanConfigSetNvtSelectionTestMixin", - "GmpModifyScanConfigSetScannerPreferenceTestMixin", - "GmpSyncScanConfigTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_clone_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_clone_scan_config.py deleted file mode 100644 index 3ab56ab2e..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_clone_scan_config.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpCloneScanConfigTestMixin: - def test_clone(self): - self.gmp.clone_scan_config("a1") - - self.connection.send.has_been_called_with( - "a1" - ) - - def test_missing_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.clone_scan_config("") - - with self.assertRaises(RequiredArgument): - self.gmp.clone_scan_config(None) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config.py deleted file mode 100644 index abdd60751..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpCreateScanConfigTestMixin: - def test_create_scan_config(self): - self.gmp.create_scan_config("a1", "foo") - - self.connection.send.has_been_called_with( - "" - "a1" - "foo" - "scan" - "" - ) - - def test_create_scan_config_with_comment(self): - self.gmp.create_scan_config("a1", "foo", comment="comment") - - self.connection.send.has_been_called_with( - "" - "comment" - "a1" - "foo" - "scan" - "" - ) - - def test_create_scan_config_missing_scan_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config(config_id="", name="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config(config_id=None, name="foo") - - def test_create_scan_config_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config(config_id="c1", name=None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config(config_id="c1", name="") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config_from_osp_scanner.py b/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config_from_osp_scanner.py deleted file mode 100644 index af70f0c7b..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_create_scan_config_from_osp_scanner.py +++ /dev/null @@ -1,55 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpCreateScanConfigFromOSPScannerTestMixin: - def test_create_scan_config_from_osp_scanner(self): - self.gmp.create_scan_config_from_osp_scanner("a1", "foo") - - self.connection.send.has_been_called_with( - "" - "a1" - "foo" - "scan" - "" - ) - - def test_create_scan_config_from_osp_scanner_with_comment(self): - self.gmp.create_scan_config_from_osp_scanner( - "a1", "foo", comment="comment" - ) - - self.connection.send.has_been_called_with( - "" - "comment" - "a1" - "foo" - "scan" - "" - ) - - def test_create_scan_config_from_osp_scanner_missing_scanner_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config_from_osp_scanner( - scanner_id="", name="foo" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config_from_osp_scanner( - scanner_id=None, name="foo" - ) - - def test_create_scan_config_from_osp_scanner_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config_from_osp_scanner( - scanner_id="c1", name=None - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scan_config_from_osp_scanner( - scanner_id="c1", name="" - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_delete_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_delete_scan_config.py deleted file mode 100644 index d07a2c9cc..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_delete_scan_config.py +++ /dev/null @@ -1,29 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import GvmError - - -class GmpDeleteScanConfigTestMixin: - def test_delete_scan_config(self): - self.gmp.delete_scan_config("a1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_delete_scan_config_ultimate(self): - self.gmp.delete_scan_config("a1", ultimate=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_delete_scan_config_missing_scan_config_id(self): - with self.assertRaises(GvmError): - self.gmp.delete_scan_config(None) - - with self.assertRaises(GvmError): - self.gmp.delete_scan_config("") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config.py deleted file mode 100644 index 86a0fcbd3..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config.py +++ /dev/null @@ -1,30 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import GvmError - - -class GmpGetScanConfigTestMixin: - def test_get_scan_config(self): - self.gmp.get_scan_config("a1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_config_with_tasks(self): - self.gmp.get_scan_config("a1", tasks=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_config_fail_without_scan_config_id(self): - with self.assertRaises(GvmError): - self.gmp.get_scan_config(None) - - with self.assertRaises(GvmError): - self.gmp.get_scan_config("") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preference.py b/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preference.py deleted file mode 100644 index 807bac826..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preference.py +++ /dev/null @@ -1,39 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpGetScanConfigPreferenceTestMixin: - def test_get_preference(self): - self.gmp.get_scan_config_preference(name="foo") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_config_preference_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.get_scan_config_preference(name=None) - - with self.assertRaises(RequiredArgument): - self.gmp.get_scan_config_preference(name="") - - with self.assertRaises(RequiredArgument): - self.gmp.get_scan_config_preference("") - - def test_get_scan_config_preference_with_nvt_oid(self): - self.gmp.get_scan_config_preference(name="foo", nvt_oid="oid") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_config_preference_with_config_id(self): - self.gmp.get_scan_config_preference(name="foo", config_id="c1") - - self.connection.send.has_been_called_with( - '' - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preferences.py b/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preferences.py deleted file mode 100644 index 5fa8093f0..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_config_preferences.py +++ /dev/null @@ -1,25 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -class GmpGetScanConfigPreferencesTestMixin: - def test_get_scan_config_preferences(self): - self.gmp.get_scan_config_preferences() - - self.connection.send.has_been_called_with("") - - def test_get_scan_config_preferences_with_nvt_oid(self): - self.gmp.get_scan_config_preferences(nvt_oid="oid") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_config_preferences_with_config_id(self): - self.gmp.get_scan_config_preferences(config_id="c1") - - self.connection.send.has_been_called_with( - '' - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_configs.py b/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_configs.py deleted file mode 100644 index f11d5e874..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_get_scan_configs.py +++ /dev/null @@ -1,90 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -class GmpGetScanConfigsTestMixin: - def test_get_scan_configs_simple(self): - self.gmp.get_scan_configs() - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_filter_string(self): - self.gmp.get_scan_configs(filter_string="name=foo") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_filter_id(self): - self.gmp.get_scan_configs(filter_id="f1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_from_trash(self): - self.gmp.get_scan_configs(trash=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_details(self): - self.gmp.get_scan_configs(details=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_without_details(self): - self.gmp.get_scan_configs(details=False) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_families(self): - self.gmp.get_scan_configs(families=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_without_families(self): - self.gmp.get_scan_configs(families=False) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_preferences(self): - self.gmp.get_scan_configs(preferences=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_without_preferences(self): - self.gmp.get_scan_configs(preferences=False) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_with_tasks(self): - self.gmp.get_scan_configs(tasks=True) - - self.connection.send.has_been_called_with( - '' - ) - - def test_get_scan_configs_without_tasks(self): - self.gmp.get_scan_configs(tasks=False) - - self.connection.send.has_been_called_with( - '' - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_import_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_import_scan_config.py deleted file mode 100644 index 8873d368f..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_import_scan_config.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgument, RequiredArgument - - -class GmpImportScanConfigTestMixin: - CONFIG_XML_STRING = ( - '' - '' - "Foobar" - "Foobar config" - "2018-11-09T10:48:03Z" - "2018-11-09T10:48:03Z" - "" - "" - ) - - def test_import_scan_config(self): - self.gmp.import_scan_config(self.CONFIG_XML_STRING) - - self.connection.send.has_been_called_with( - "" f"{self.CONFIG_XML_STRING}" "" - ) - - def test_import_missing_scan_config_xml(self): - with self.assertRaises(RequiredArgument): - self.gmp.import_scan_config(None) - - with self.assertRaises(RequiredArgument): - self.gmp.import_scan_config("") - - def test_import_invalid_xml(self): - with self.assertRaises(InvalidArgument): - self.gmp.import_scan_config("abcdef") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config.py deleted file mode 100644 index b3530a030..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config.py +++ /dev/null @@ -1,137 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# -import warnings - -from gvm.errors import InvalidArgument, RequiredArgument - - -class GmpModifyScanConfigTestMixin: - def test_modify_scan_config_invalid_selection(self): - with self.assertRaises(InvalidArgument): - self.gmp.modify_scan_config(config_id="c1", selection="foo") - - with self.assertRaises(InvalidArgument): - self.gmp.modify_scan_config(config_id="c1", selection="") - - def test_modify_scan_config_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config(config_id=None, selection="nvt_pref") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config(config_id="", selection="nvt_pref") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config("", selection="nvt_pref") - - def test_modify_scan_config_set_comment(self): - # pylint: disable=invalid-name - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - self.gmp.modify_scan_config( - config_id="c1", selection=None, comment="foo" - ) - - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, DeprecationWarning)) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scan_config_set_nvt_pref(self): - # pylint: disable=invalid-name - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - self.gmp.modify_scan_config( - config_id="c1", selection="nvt_pref", nvt_oid="o1", name="foo" - ) - - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, DeprecationWarning)) - - self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" - ) - - def test_modify_scan_config_set_scanner_pref(self): - # pylint: disable=invalid-name - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - self.gmp.modify_scan_config( - config_id="c1", selection="scan_pref", name="foo", value="bar" - ) - - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, DeprecationWarning)) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - "YmFy" - "" - "" - ) - - def test_modify_scan_config_set_nvt_selection(self): - # pylint: disable=invalid-name - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - self.gmp.modify_scan_config( - config_id="c1", - selection="nvt_selection", - nvt_oids=["o1"], - family="foo", - ) - - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, DeprecationWarning)) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" - ) - - def test_modify_scan_config_set_family_selection(self): - # pylint: disable=invalid-name - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - self.gmp.modify_scan_config( - config_id="c1", - selection="family_selection", - families=[("foo", True, True)], - ) - - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, DeprecationWarning)) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_comment.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_comment.py deleted file mode 100644 index 3fac21010..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_comment.py +++ /dev/null @@ -1,43 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpModifyScanConfigSetCommentTestMixin: - def test_modify_scan_config_set_comment(self): - self.gmp.modify_scan_config_set_comment("c1") - - self.connection.send.has_been_called_with( - '' - "" - "" - ) - - self.gmp.modify_scan_config_set_comment("c1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - self.gmp.modify_scan_config_set_comment("c1", comment=None) - - self.connection.send.has_been_called_with( - '' - "" - "" - ) - - def test_modify_scan_config_set_comment_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_comment(config_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_comment("") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_comment(config_id="") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_family_selection.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_family_selection.py deleted file mode 100644 index 2b00eb4cc..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_family_selection.py +++ /dev/null @@ -1,244 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument - - -class GmpModifyScanConfigSetFamilySelectionTestMixin: - def test_modify_scan_config_set_family_selection(self): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", True, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", True, True), ("bar", True, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "bar" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=(("foo", True, True), ("bar", True, True)) - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "bar" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", - families=[("foo", True, False), ("bar", False, True)], - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "0" - "1" - "" - "" - "bar" - "1" - "0" - "" - "" - "" - ) - - def test_modify_scan_config_set_family_selection_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_family_selection( - config_id=None, families=[("foo", True, True)] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_family_selection( - config_id="", families=[("foo", True, True)] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_family_selection( - "", [("foo", True)] - ) - - def test_modify_scan_config_set_family_selection_invalid_families(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=None - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families="" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection("c1", "") - - def test_modify_scan_config_set_family_selection_with_auto_add_new_families( - self, - ): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", - families=[("foo", True, True)], - auto_add_new_families=True, - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", - families=[("foo", True, True)], - auto_add_new_families=False, - ) - - self.connection.send.has_been_called_with( - '' - "" - "0" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( - self, - ): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", True, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", False, True)] - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "" - ) - - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", - families=[("foo", False, True), ("bar", True, False)], - ) - - self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "bar" - "0" - "1" - "" - "" - "" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", "False", "True")] - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", True, None)] - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo", "True", False)] - ) - - with self.assertRaises(InvalidArgument): - self.gmp.modify_scan_config_set_family_selection( - config_id="c1", families=[("foo",)] - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_name.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_name.py deleted file mode 100644 index f4481e76f..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_name.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpModifyScanConfigSetNameTestMixin: - def test_modify_scan_config_set_name(self): - self.gmp.modify_scan_config_set_name("c1", "foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scan_config_set_name_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name(config_id=None, name="name") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name("", name="name") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name(config_id="", name="name") - - def test_modify_scan_config_set_name_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name(config_id="c", name="") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name(config_id="c", name=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_name("c", "") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py deleted file mode 100644 index 59aba32b9..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py +++ /dev/null @@ -1,94 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpModifyScanConfigSetNvtPreferenceTestMixin: - def test_modify_scan_config_set_nvt_pref(self): - self.gmp.modify_scan_config_set_nvt_preference( - config_id="c1", nvt_oid="o1", name="foo" - ) - - self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" - ) - - self.gmp.modify_scan_config_set_nvt_preference("c1", "foo", "o1") - - self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" - ) - - def test_modify_scan_config_set_nvt_pref_with_value(self): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", "foo", nvt_oid="o1", value="bar" - ) - - self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "YmFy" - "" - "" - ) - - def test_modify_scan_config_set_nvt_pref_missing_nvt_oid(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", "foo", nvt_oid=None, value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", "foo", nvt_oid="", value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", "foo", "", value="bar" - ) - - def test_modify_scan_config_nvt_pref_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", name=None, nvt_oid="o1", value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", name="", nvt_oid="o1", value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - "c1", "", nvt_oid="o1", value="bar" - ) - - def test_modify_scan_config_set_comment_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - config_id=None, name="foo", nvt_oid="o1" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference("", "foo", "o1") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_preference( - config_id="", name="foo", nvt_oid="o1" - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py deleted file mode 100644 index aae8df6da..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py +++ /dev/null @@ -1,113 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument - - -class GmpModifyScanConfigSetNvtSelectionTestMixin: - def test_modify_scan_config_set_nvt_selection(self): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="foo", nvt_oids=["o1"] - ) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" - ) - - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="foo", nvt_oids=["o1", "o2"] - ) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" - ) - - self.gmp.modify_scan_config_set_nvt_selection("c1", "foo", ["o1"]) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" - ) - - self.gmp.modify_scan_config_set_nvt_selection("c1", "foo", ("o1", "o2")) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" - ) - - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="foo", nvt_oids=[] - ) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" - ) - - def test_modify_scan_config_set_nvt_selection_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection( - config_id=None, family="foo", nvt_oids=["o1"] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="", family="foo", nvt_oids=["o1"] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection("", "foo", ["o1"]) - - def test_modify_scan_config_set_nvt_selection_missing_family(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family=None, nvt_oids=["o1"] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="", nvt_oids=["o1"] - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_nvt_selection("c1", "", ["o1"]) - - def test_modify_scan_config_set_nvt_selection_invalid_nvt_oids(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="foo", nvt_oids=None - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_nvt_selection( - config_id="c1", family="foo", nvt_oids="" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scan_config_set_nvt_selection("c1", "foo", "") diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py b/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py deleted file mode 100644 index c43ab72d2..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py +++ /dev/null @@ -1,75 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpModifyScanConfigSetScannerPreferenceTestMixin: - def test_modify_scan_config_set_scanner_pref(self): - self.gmp.modify_scan_config_set_scanner_preference( - config_id="c1", name="foo" - ) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" - ) - - self.gmp.modify_scan_config_set_scanner_preference("c1", "foo") - - self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" - ) - - def test_modify_scan_config_set_scanner_pref_with_value(self): - self.gmp.modify_scan_config_set_scanner_preference( - "c1", "foo", value="bar" - ) - - self.connection.send.has_been_called_with( - '' - "" - "foo" - "YmFy" - "" - "" - ) - - def test_modify_scan_config_scanner_pref_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference( - "c1", name=None, value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference( - "c1", name="", value="bar" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference( - "c1", "", value="bar" - ) - - def test_modify_scan_config_set_comment_missing_config_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference( - config_id=None, name="foo" - ) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference("", "foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scan_config_set_scanner_preference( - config_id="", name="foo" - ) diff --git a/tests/protocols/gmpv208/entities/scan_configs/test_sync_scan_config.py b/tests/protocols/gmpv208/entities/scan_configs/test_sync_scan_config.py deleted file mode 100644 index 0b7b36e72..000000000 --- a/tests/protocols/gmpv208/entities/scan_configs/test_sync_scan_config.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -class GmpSyncScanConfigTestMixin: - def test_sync_scan_config(self): - self.gmp.sync_scan_config() - - self.connection.send.has_been_called_with("") diff --git a/tests/protocols/gmpv208/entities/scanners/__init__.py b/tests/protocols/gmpv208/entities/scanners/__init__.py deleted file mode 100644 index 97e2d0313..000000000 --- a/tests/protocols/gmpv208/entities/scanners/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_scanner import GmpCloneScannerTestMixin -from .test_create_scanner import GmpCreateScannerTestMixin -from .test_delete_scanner import GmpDeleteScannerTestMixin -from .test_get_scanner import GmpGetScannerTestMixin -from .test_get_scanners import GmpGetScannersTestMixin -from .test_modify_scanner import GmpModifyScannerTestMixin -from .test_verify_scanner import GmpVerifyScannerTestMixin - -__all__ = ( - "GmpCloneScannerTestMixin", - "GmpCreateScannerTestMixin", - "GmpDeleteScannerTestMixin", - "GmpGetScannerTestMixin", - "GmpGetScannersTestMixin", - "GmpModifyScannerTestMixin", - "GmpVerifyScannerTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/scanners/test_create_scanner.py b/tests/protocols/gmpv208/entities/scanners/test_create_scanner.py deleted file mode 100644 index 23aee94a4..000000000 --- a/tests/protocols/gmpv208/entities/scanners/test_create_scanner.py +++ /dev/null @@ -1,184 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import ScannerType - - -class GmpCreateScannerTestMixin: - def test_create_scanner(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - '' - "" - ) - - def test_create_scanner_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name=None, - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="", - host="localhost", - port=1234, - scanner_type="1", - credential_id="c1", - ) - - def test_create_scanner_missing_host(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host=None, - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - def test_create_scanner_missing_port(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=None, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port="", - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - def test_create_scanner_missing_scanner_type(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=None, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="", - credential_id="c1", - ) - - def test_create_scanner_missing_credential_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id=None, - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="", - ) - - def test_create_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="bar", - credential_id="c1", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="55", - credential_id="c1", - ) - - def test_create_scanner_with_ca_pub(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - ca_pub="foo", - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - "foo" - '' - "" - ) - - def test_create_scanner_with_comment(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - comment="bar", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - '' - "bar" - "" - ) diff --git a/tests/protocols/gmpv208/entities/scanners/test_modify_scanner.py b/tests/protocols/gmpv208/entities/scanners/test_modify_scanner.py deleted file mode 100644 index 7be7256a4..000000000 --- a/tests/protocols/gmpv208/entities/scanners/test_modify_scanner.py +++ /dev/null @@ -1,136 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import ScannerType - - -class GmpModifyScannerTestMixin: - def test_modify_scanner(self): - self.gmp.modify_scanner(scanner_id="s1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_modify_scanner_missing_scanner_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scanner(scanner_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scanner(scanner_id="") - - def test_modify_scanner_with_comment(self): - self.gmp.modify_scanner(scanner_id="s1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_host(self): - self.gmp.modify_scanner(scanner_id="s1", host="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_port(self): - self.gmp.modify_scanner(scanner_id="s1", port=1234) - - self.connection.send.has_been_called_with( - '' - "1234" - "" - ) - - self.gmp.modify_scanner(scanner_id="s1", port="1234") - - self.connection.send.has_been_called_with( - '' - "1234" - "" - ) - - def test_modify_scanner_with_name(self): - self.gmp.modify_scanner(scanner_id="s1", name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_ca_pub(self): - self.gmp.modify_scanner(scanner_id="s1", ca_pub="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_credential_id(self): - self.gmp.modify_scanner(scanner_id="s1", credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_scanner_with_scanner_type(self): - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.OSP_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.OPENVAS_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "2" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.CVE_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "3" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.GMP_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "4" - "" - ) - - def test_modify_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type="-1") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type=1) diff --git a/tests/protocols/gmpv208/entities/targets/__init__.py b/tests/protocols/gmpv208/entities/targets/__init__.py deleted file mode 100644 index 27b214c3a..000000000 --- a/tests/protocols/gmpv208/entities/targets/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_target import GmpCloneTargetTestMixin -from .test_create_target import GmpCreateTargetTestMixin -from .test_delete_target import GmpDeleteTargetTestMixin -from .test_get_target import GmpGetTargetTestMixin -from .test_get_targets import GmpGetTargetsTestMixin -from .test_modify_target import GmpModifyTargetTestMixin - -__all__ = ( - "GmpCloneTargetTestMixin", - "GmpCreateTargetTestMixin", - "GmpDeleteTargetTestMixin", - "GmpGetTargetTestMixin", - "GmpGetTargetsTestMixin", - "GmpModifyTargetTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/targets/test_create_target.py b/tests/protocols/gmpv208/entities/targets/test_create_target.py deleted file mode 100644 index 2c55550d2..000000000 --- a/tests/protocols/gmpv208/entities/targets/test_create_target.py +++ /dev/null @@ -1,246 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.targets import AliveTest - - -class GmpCreateTargetTestMixin: - def test_create_target_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_target(None, hosts=["foo"]) - - with self.assertRaises(RequiredArgument): - self.gmp.create_target(name=None, hosts=["foo"]) - - with self.assertRaises(RequiredArgument): - self.gmp.create_target("", hosts=["foo"]) - - def test_create_target_with_asset_hosts_filter(self): - self.gmp.create_target( - "foo", port_list_id="pl1", asset_hosts_filter="name=foo" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_target_missing_hosts(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_target(name="foo") - - def test_create_target_with_comment(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", comment="bar" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - '' - "" - ) - - def test_create_target_with_exclude_hosts(self): - self.gmp.create_target( - "foo", - hosts=["foo", "bar"], - port_list_id="pl1", - exclude_hosts=["bar", "ipsum"], - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo,bar" - "bar,ipsum" - '' - "" - ) - - def test_create_target_with_ssh_credential(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", ssh_credential_id="c1" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - '' - "" - ) - - def test_create_target_with_ssh_credential_port(self): - self.gmp.create_target( - "foo", - hosts=["foo"], - port_list_id="pl1", - ssh_credential_id="c1", - ssh_credential_port=123, - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "123" - "" - '' - "" - ) - - def test_create_target_with_smb_credential_id(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", smb_credential_id="c1" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - '' - "" - ) - - def test_create_target_with_esxi_credential_id(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", esxi_credential_id="c1" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - '' - "" - ) - - def test_create_target_with_snmp_credential_id(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", snmp_credential_id="c1" - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - '' - "" - ) - - def test_create_target_with_alive_tests(self): - self.gmp.create_target( - "foo", - hosts=["foo"], - port_list_id="pl1", - alive_test=AliveTest.ICMP_PING, - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "ICMP Ping" - '' - "" - ) - - def test_create_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", alive_test="foo" - ) - - def test_create_target_with_reverse_lookup_only(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", reverse_lookup_only=True - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - '' - "" - ) - - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", reverse_lookup_only=False - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - '' - "" - ) - - def test_create_target_with_reverse_lookup_unify(self): - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", reverse_lookup_unify=True - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - '' - "" - ) - - self.gmp.create_target( - "foo", hosts=["foo"], port_list_id="pl1", reverse_lookup_unify=False - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - '' - "" - ) - - def test_create_target_with_port_range(self): - self.gmp.create_target("foo", hosts=["foo"], port_range="bar") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - "" - ) - - def test_create_target_with_port_list_id(self): - self.gmp.create_target("foo", hosts=["foo"], port_list_id="pl1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) - - def test_create_target_without_ports(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_target("foo", hosts=["foo"]) diff --git a/tests/protocols/gmpv208/entities/targets/test_modify_target.py b/tests/protocols/gmpv208/entities/targets/test_modify_target.py deleted file mode 100644 index 03f39bd6e..000000000 --- a/tests/protocols/gmpv208/entities/targets/test_modify_target.py +++ /dev/null @@ -1,194 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.targets import AliveTest - - -class GmpModifyTargetTestMixin: - def test_modify_target(self): - self.gmp.modify_target(target_id="t1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_modify_target_missing_target_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_target(target_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_target(target_id="") - - def test_modify_target_with_comment(self): - self.gmp.modify_target(target_id="t1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_target_with_hosts(self): - self.gmp.modify_target(target_id="t1", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - "" - ) - - self.gmp.modify_target(target_id="t1", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "" - "" - ) - - def test_modify_target_with_hosts_and_exclude_hosts(self): - self.gmp.modify_target( - target_id="t1", hosts=["foo", "bar"], exclude_hosts=["foo"] - ) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "foo" - "" - ) - - def test_modify_target_with_name(self): - self.gmp.modify_target(target_id="t1", name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_target_with_exclude_hosts(self): - self.gmp.modify_target(target_id="t1", exclude_hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - self.gmp.modify_target(target_id="t1", exclude_hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "" - ) - - def test_modify_target_with_ssh_credential(self): - self.gmp.modify_target(target_id="t1", ssh_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_ssh_credential_port(self): - self.gmp.modify_target( - target_id="t1", ssh_credential_id="c1", ssh_credential_port=123 - ) - - self.connection.send.has_been_called_with( - '' - '' - "123" - "" - "" - ) - - def test_modify_target_with_smb_credential_id(self): - self.gmp.modify_target(target_id="t1", smb_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_esxi_credential_id(self): - self.gmp.modify_target(target_id="t1", esxi_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_snmp_credential_id(self): - self.gmp.modify_target(target_id="t1", snmp_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_alive_tests(self): - self.gmp.modify_target(target_id="t1", alive_test=AliveTest.ICMP_PING) - - self.connection.send.has_been_called_with( - '' - "ICMP Ping" - "" - ) - - def test_modify_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_target(target_id="t1", alive_test="foo") - - def test_modify_target_with_reverse_lookup_only(self): - self.gmp.modify_target(target_id="t1", reverse_lookup_only=True) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_target(target_id="t1", reverse_lookup_only=False) - - self.connection.send.has_been_called_with( - '' - "0" - "" - ) - - def test_modify_target_with_reverse_lookup_unify(self): - self.gmp.modify_target(target_id="t1", reverse_lookup_unify=True) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_target(target_id="t1", reverse_lookup_unify=False) - - self.connection.send.has_been_called_with( - '' - "0" - "" - ) - - def test_modify_target_with_port_list_id(self): - self.gmp.modify_target(target_id="t1", port_list_id="pl1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) diff --git a/tests/protocols/gmpv208/entities/test_alerts.py b/tests/protocols/gmpv208/entities/test_alerts.py deleted file mode 100644 index 3326c9dba..000000000 --- a/tests/protocols/gmpv208/entities/test_alerts.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .alerts import ( - GmpCloneAlertTestMixin, - GmpCreateAlertTestMixin, - GmpDeleteAlertTestMixin, - GmpGetAlertsTestMixin, - GmpGetAlertTestMixin, - GmpModifyAlertTestMixin, - GmpTestAlertTestMixin, - GmpTriggerAlertTestMixin, -) - - -class Gmpv208CloneAlertTestCase(GmpCloneAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateAlertTestCase(GmpCreateAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteAlertTestCase(GmpDeleteAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetAlertTestCase(GmpGetAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetAlertsTestCase(GmpGetAlertsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyAlertTestCase(GmpModifyAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208TestAlertTestCase(GmpTestAlertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208TriggerAlertTestCase(GmpTriggerAlertTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_audits.py b/tests/protocols/gmpv208/entities/test_audits.py deleted file mode 100644 index ca5d67758..000000000 --- a/tests/protocols/gmpv208/entities/test_audits.py +++ /dev/null @@ -1,53 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .audits import ( - GmpCloneAuditTestMixin, - GmpCreateAuditTestMixin, - GmpDeleteAuditTestMixin, - GmpGetAuditsTestMixin, - GmpGetAuditTestMixin, - GmpModifyAuditTestMixin, - GmpResumeAuditTestMixin, - GmpStartAuditTestMixin, - GmpStopAuditTestMixin, -) - - -class Gmpv208CloneAuditTestCase(GmpCloneAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateAuditTestCase(GmpCreateAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteAuditTestCase(GmpDeleteAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetAuditTestCase(GmpGetAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetAuditsTestCase(GmpGetAuditsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyAuditTestCase(GmpModifyAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ResumeAuditTestCase(GmpResumeAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208StartAuditTestCase(GmpStartAuditTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208StopAuditTestCase(GmpStopAuditTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_credentials.py b/tests/protocols/gmpv208/entities/test_credentials.py deleted file mode 100644 index 7e0f816ae..000000000 --- a/tests/protocols/gmpv208/entities/test_credentials.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .credentials import ( - GmpCloneCredentialTestMixin, - GmpCreateCredentialTestMixin, - GmpDeleteCredentialTestMixin, - GmpGetCredentialsTestMixin, - GmpGetCredentialTestMixin, - GmpModifyCredentialTestMixin, -) - - -class Gmpv208CloneCredentialTestCase( - GmpCloneCredentialTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreateCredentialTestCase( - GmpCreateCredentialTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeleteCredentialTestCase( - GmpDeleteCredentialTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetCredentialTestCase(GmpGetCredentialTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetCredentialsTestCase( - GmpGetCredentialsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyCredentialTestCase( - GmpModifyCredentialTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_filters.py b/tests/protocols/gmpv208/entities/test_filters.py deleted file mode 100644 index 775a32e00..000000000 --- a/tests/protocols/gmpv208/entities/test_filters.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .filters import ( - GmpCloneFilterTestMixin, - GmpCreateFilterTestMixin, - GmpDeleteFilterTestMixin, - GmpGetFiltersTestMixin, - GmpGetFilterTestMixin, - GmpModifyFilterTestMixin, -) - - -class Gmpv208DeleteFilterTestCase(GmpDeleteFilterTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetFilterTestCase(GmpGetFilterTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetFiltersTestCase(GmpGetFiltersTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneFilterTestCase(GmpCloneFilterTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateFilterTestCase(GmpCreateFilterTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyFilterTestCase(GmpModifyFilterTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_groups.py b/tests/protocols/gmpv208/entities/test_groups.py deleted file mode 100644 index d9086a052..000000000 --- a/tests/protocols/gmpv208/entities/test_groups.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .groups import ( - GmpCloneGroupTestMixin, - GmpCreateGroupTestMixin, - GmpDeleteGroupTestMixin, - GmpGetGroupsTestMixin, - GmpGetGroupTestMixin, - GmpModifyGroupTestMixin, -) - - -class Gmpv208DeleteGroupTestCase(GmpDeleteGroupTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetGroupTestCase(GmpGetGroupTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetGroupsTestCase(GmpGetGroupsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneGroupTestCase(GmpCloneGroupTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateGroupTestCase(GmpCreateGroupTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyGroupTestCase(GmpModifyGroupTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_hosts.py b/tests/protocols/gmpv208/entities/test_hosts.py deleted file mode 100644 index e9f5eede3..000000000 --- a/tests/protocols/gmpv208/entities/test_hosts.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .hosts import ( - GmpCreateHostTestMixin, - GmpDeleteHostTestMixin, - GmpGetHostsTestMixin, - GmpGetHostTestMixin, - GmpModifyHostTestMixin, -) - - -class Gmpv208CreateHostTestCase(GmpCreateHostTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteHostTestCase(GmpDeleteHostTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetHostTestCase(GmpGetHostTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetHostsTestCase(GmpGetHostsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyHostTestCase(GmpModifyHostTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_notes.py b/tests/protocols/gmpv208/entities/test_notes.py deleted file mode 100644 index 5f816ba04..000000000 --- a/tests/protocols/gmpv208/entities/test_notes.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .notes import ( - GmpCloneNoteTestMixin, - GmpCreateNoteTestMixin, - GmpDeleteNoteTestMixin, - GmpGetNotesTestMixin, - GmpGetNoteTestMixin, - GmpModifyNoteTestMixin, -) - - -class Gmpv208DeleteNoteTestCase(GmpDeleteNoteTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetNoteTestCase(GmpGetNoteTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetNotesTestCase(GmpGetNotesTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneNoteTestCase(GmpCloneNoteTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateNoteTestCase(GmpCreateNoteTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyNoteTestCase(GmpModifyNoteTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_operating_systems.py b/tests/protocols/gmpv208/entities/test_operating_systems.py deleted file mode 100644 index ad74a6c9e..000000000 --- a/tests/protocols/gmpv208/entities/test_operating_systems.py +++ /dev/null @@ -1,36 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .operating_systems import ( - GmpDeleteOperatingSystemTestMixin, - GmpGetOperatingSystemsTestMixin, - GmpGetOperatingSystemTestMixin, - GmpModifyOperatingSystemTestMixin, -) - - -class Gmpv208DeleteOperatingSystemTestCase( - GmpDeleteOperatingSystemTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetOperatingSystemTestCase( - GmpGetOperatingSystemTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetOperatingSystemsTestCase( - GmpGetOperatingSystemsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyOperatingSystemTestCase( - GmpModifyOperatingSystemTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_overrides.py b/tests/protocols/gmpv208/entities/test_overrides.py deleted file mode 100644 index 395d2eef8..000000000 --- a/tests/protocols/gmpv208/entities/test_overrides.py +++ /dev/null @@ -1,44 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .overrides import ( - GmpCloneOverrideTestMixin, - GmpCreateOverrideTestMixin, - GmpDeleteOverrideTestMixin, - GmpGetOverridesTestMixin, - GmpGetOverrideTestMixin, - GmpModifyOverrideTestMixin, -) - - -class Gmpv208CloneOverrideTestCase(GmpCloneOverrideTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateOverrideTestCase( - GmpCreateOverrideTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeleteOverrideTestCase( - GmpDeleteOverrideTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetOverrideTestCase(GmpGetOverrideTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetOverridesTestCase(GmpGetOverridesTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyOverrideTestCase( - GmpModifyOverrideTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_permissions.py b/tests/protocols/gmpv208/entities/test_permissions.py deleted file mode 100644 index 592becd85..000000000 --- a/tests/protocols/gmpv208/entities/test_permissions.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .permissions import ( - GmpClonePermissionTestMixin, - GmpCreatePermissionTestMixin, - GmpDeletePermissionTestMixin, - GmpGetPermissionsTestMixin, - GmpGetPermissionTestMixin, - GmpModifyPermissionTestMixin, -) - - -class Gmpv208DeletePermissionTestCase( - GmpDeletePermissionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetPermissionTestCase(GmpGetPermissionTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetPermissionsTestCase( - GmpGetPermissionsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ClonePermissionTestCase( - GmpClonePermissionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreatePermissionTestCase( - GmpCreatePermissionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPermissionTestCase( - GmpModifyPermissionTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_policies.py b/tests/protocols/gmpv208/entities/test_policies.py deleted file mode 100644 index 083190f02..000000000 --- a/tests/protocols/gmpv208/entities/test_policies.py +++ /dev/null @@ -1,80 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .policies import ( - GmpClonePolicyTestMixin, - GmpCreatePolicyTestMixin, - GmpDeletePolicyTestMixin, - GmpGetPoliciesTestMixin, - GmpGetPolicyTestMixin, - GmpImportPolicyTestMixin, - GmpModifyPolicySetCommentTestMixin, - GmpModifyPolicySetFamilySelectionTestMixin, - GmpModifyPolicySetNameTestMixin, - GmpModifyPolicySetNvtPreferenceTestMixin, - GmpModifyPolicySetNvtSelectionTestMixin, - GmpModifyPolicySetScannerPreferenceTestMixin, -) - - -class Gmpv208ClonePolicyTestCase(GmpClonePolicyTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreatePolicyTestCase(GmpCreatePolicyTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeletePolicyTestCase(GmpDeletePolicyTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetPolicyTestCase(GmpGetPolicyTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetPoliciesTestCase(GmpGetPoliciesTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ImportPolicyTestCase(GmpImportPolicyTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyPolicySetCommentTestCase( - GmpModifyPolicySetCommentTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPolicySetFamilySelectionTestCase( - GmpModifyPolicySetFamilySelectionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPolicySetNvtSelectionTestCase( - GmpModifyPolicySetNvtSelectionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPolicySetNameTestCase( - GmpModifyPolicySetNameTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPolicySetNvtPreferenceTestCase( - GmpModifyPolicySetNvtPreferenceTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyPolicySetScannerPreferenceTestCase( - GmpModifyPolicySetScannerPreferenceTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_port_lists.py b/tests/protocols/gmpv208/entities/test_port_lists.py deleted file mode 100644 index 332e845ee..000000000 --- a/tests/protocols/gmpv208/entities/test_port_lists.py +++ /dev/null @@ -1,58 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .port_lists import ( - GmpClonePortListTestMixin, - GmpCreatePortListTestMixin, - GmpCreatePortRangeTestMixin, - GmpDeletePortListTestMixin, - GmpDeletePortRangeTestMixin, - GmpGetPortListsTestMixin, - GmpGetPortListTestMixin, - GmpModifyPortListTestMixin, -) - - -class Gmpv208ClonePortListTestCase(GmpClonePortListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreatePortListTestCase( - GmpCreatePortListTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreatePortRangeListTestCase( - GmpCreatePortRangeTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeletePortListTestCase( - GmpDeletePortListTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeletePortRangeTestCase( - GmpDeletePortRangeTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetPortListTestCase(GmpGetPortListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetPortListsTestCase(GmpGetPortListsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyPortListTestCase( - GmpModifyPortListTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_report_formats.py b/tests/protocols/gmpv208/entities/test_report_formats.py deleted file mode 100644 index 80b45239a..000000000 --- a/tests/protocols/gmpv208/entities/test_report_formats.py +++ /dev/null @@ -1,57 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .report_formats import ( - GmpCloneReportFormatTestMixin, - GmpDeleteReportFormatTestMixin, - GmpGetReportFormatsTestMixin, - GmpGetReportFormatTestMixin, - GmpImportReportFormatTestMixin, - GmpModifyReportFormatTestMixin, - GmpVerifyReportFormatTestMixin, -) - - -class Gmpv208DeleteReportFormatTestCase( - GmpDeleteReportFormatTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetReportFormatTestCase( - GmpGetReportFormatTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetReportFormatsTestCase( - GmpGetReportFormatsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CloneReportFormatTestCase( - GmpCloneReportFormatTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ImportReportFormatTestCase( - GmpImportReportFormatTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyReportFormatTestCase( - GmpModifyReportFormatTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208VerifyReportFormatTestCase( - GmpVerifyReportFormatTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_reports.py b/tests/protocols/gmpv208/entities/test_reports.py deleted file mode 100644 index 6a1453c17..000000000 --- a/tests/protocols/gmpv208/entities/test_reports.py +++ /dev/null @@ -1,28 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .reports import ( - GmpDeleteReportTestMixin, - GmpGetReportsTestMixin, - GmpGetReportTestMixin, - GmpImportReportTestMixin, -) - - -class Gmpv208DeleteReportTestCase(GmpDeleteReportTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetReportTestCase(GmpGetReportTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetReportsTestCase(GmpGetReportsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ImportReportTestCase(GmpImportReportTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_results.py b/tests/protocols/gmpv208/entities/test_results.py deleted file mode 100644 index 1bf981e7a..000000000 --- a/tests/protocols/gmpv208/entities/test_results.py +++ /dev/null @@ -1,15 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .results import GmpGetResultsTestMixin, GmpGetResultTestMixin - - -class Gmpv208GetResultTestCase(GmpGetResultTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetResultsTestCase(GmpGetResultsTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_roles.py b/tests/protocols/gmpv208/entities/test_roles.py deleted file mode 100644 index b9611cb79..000000000 --- a/tests/protocols/gmpv208/entities/test_roles.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .roles import ( - GmpCloneRoleTestMixin, - GmpCreateRoleTestMixin, - GmpDeleteRoleTestMixin, - GmpGetRolesTestMixin, - GmpGetRoleTestMixin, - GmpModifyRoleTestMixin, -) - - -class Gmpv208DeleteRoleTestCase(GmpDeleteRoleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetRoleTestCase(GmpGetRoleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetRolesTestCase(GmpGetRolesTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneRoleTestCase(GmpCloneRoleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateRoleTestCase(GmpCreateRoleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyRoleTestCase(GmpModifyRoleTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_scan_configs.py b/tests/protocols/gmpv208/entities/test_scan_configs.py deleted file mode 100644 index 53465bd93..000000000 --- a/tests/protocols/gmpv208/entities/test_scan_configs.py +++ /dev/null @@ -1,125 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .scan_configs import ( - GmpCloneScanConfigTestMixin, - GmpCreateScanConfigFromOSPScannerTestMixin, - GmpCreateScanConfigTestMixin, - GmpDeleteScanConfigTestMixin, - GmpGetScanConfigPreferencesTestMixin, - GmpGetScanConfigPreferenceTestMixin, - GmpGetScanConfigsTestMixin, - GmpGetScanConfigTestMixin, - GmpImportScanConfigTestMixin, - GmpModifyScanConfigSetCommentTestMixin, - GmpModifyScanConfigSetFamilySelectionTestMixin, - GmpModifyScanConfigSetNameTestMixin, - GmpModifyScanConfigSetNvtPreferenceTestMixin, - GmpModifyScanConfigSetNvtSelectionTestMixin, - GmpModifyScanConfigSetScannerPreferenceTestMixin, - GmpModifyScanConfigTestMixin, - GmpSyncScanConfigTestMixin, -) - - -class Gmpv208CloneScanConfigTestCase( - GmpCloneScanConfigTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreateScanConfigTestCase( - GmpCreateScanConfigTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreateScanConfigFromOSPScannerTestCase( - GmpCreateScanConfigFromOSPScannerTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeleteScanConfigTestCase( - GmpDeleteScanConfigTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScanConfigTestCase(GmpGetScanConfigTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetScanConfigsTestCase( - GmpGetScanConfigsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScanConfigPreferenceTestCase( - GmpGetScanConfigPreferenceTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScanConfigPreferencesTestCase( - GmpGetScanConfigPreferencesTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ImportScanConfigTestCase( - GmpImportScanConfigTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetCommentTestCase( - GmpModifyScanConfigSetCommentTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetFamilySelectionTestCase( - GmpModifyScanConfigSetFamilySelectionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetNvtSelectionTestCase( - GmpModifyScanConfigSetNvtSelectionTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetNameTestCase( - GmpModifyScanConfigSetNameTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetNvtPreferenceTestCase( - GmpModifyScanConfigSetNvtPreferenceTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigSetScannerPreferenceTestCase( - GmpModifyScanConfigSetScannerPreferenceTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScanConfigTestCase( - GmpModifyScanConfigTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208SyncScanConfigTestCase( - GmpSyncScanConfigTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_scanners.py b/tests/protocols/gmpv208/entities/test_scanners.py deleted file mode 100644 index 4d40d3feb..000000000 --- a/tests/protocols/gmpv208/entities/test_scanners.py +++ /dev/null @@ -1,43 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .scanners import ( - GmpCloneScannerTestMixin, - GmpCreateScannerTestMixin, - GmpDeleteScannerTestMixin, - GmpGetScannersTestMixin, - GmpGetScannerTestMixin, - GmpModifyScannerTestMixin, - GmpVerifyScannerTestMixin, -) - - -class Gmpv208CloneScannerTestCase(GmpCloneScannerTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateScannerTestCase(GmpCreateScannerTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteScannerTestCase(GmpDeleteScannerTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetScannerTestCase(GmpGetScannerTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetScannersTestCase(GmpGetScannersTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyScannerTestCase(GmpModifyScannerTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208VerifyScannerTestMixin(GmpVerifyScannerTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_schedules.py b/tests/protocols/gmpv208/entities/test_schedules.py deleted file mode 100644 index 1263fc90a..000000000 --- a/tests/protocols/gmpv208/entities/test_schedules.py +++ /dev/null @@ -1,44 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .schedules import ( - GmpCloneScheduleTestMixin, - GmpCreateScheduleTestMixin, - GmpDeleteScheduleTestMixin, - GmpGetSchedulesTestMixin, - GmpGetScheduleTestMixin, - GmpModifyScheduleTestMixin, -) - - -class Gmpv208DeleteScheduleTestCase( - GmpDeleteScheduleTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScheduleTestCase(GmpGetScheduleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetSchedulesTestCase(GmpGetSchedulesTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneScheduleTestCase(GmpCloneScheduleTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateScheduleTestCase( - GmpCreateScheduleTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyScheduleTestCase( - GmpModifyScheduleTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_secinfo.py b/tests/protocols/gmpv208/entities/test_secinfo.py deleted file mode 100644 index 0e7be1ab5..000000000 --- a/tests/protocols/gmpv208/entities/test_secinfo.py +++ /dev/null @@ -1,117 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .secinfo import ( - GmpGetCertBundListTestMixin, - GmpGetCertBundTestMixin, - GmpGetCpeListTestMixin, - GmpGetCpeTestMixin, - GmpGetCveListTestMixin, - GmpGetCveTestMixin, - GmpGetDfnCertListTestMixin, - GmpGetDfnCertTestMixin, - GmpGetInfoListTestMixin, - GmpGetInfoTestMixin, - GmpGetNvtFamiliesTestMixin, - GmpGetNvtListTestMixin, - GmpGetNvtPreferencesTestMixin, - GmpGetNvtPreferenceTestMixin, - GmpGetNvtTestMixin, - GmpGetOvalDefListTestMixin, - GmpGetOvalDefTestMixin, - GmpGetScanConfigNvtsTestMixin, - GmpGetScanConfigNvtTestMixin, -) - - -class Gmpv208GetCertBundTestCase(GmpGetCertBundTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetCpeTestCase(GmpGetCpeTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetCveTestCase(GmpGetCveTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetDfnCertCase(GmpGetDfnCertTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetOvalDefCase(GmpGetOvalDefTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetInfoListTestCase(GmpGetInfoListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetInfoTestCase(GmpGetInfoTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetNvtTestCase(GmpGetNvtTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetNvtPreferenceTestCase( - GmpGetNvtPreferenceTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetNvtPreferencesTestCase( - GmpGetNvtPreferencesTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScanConfigNvtTestCase( - GmpGetScanConfigNvtTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetNvtFamiliesTestCase( - GmpGetNvtFamiliesTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetScanConfigNvtsTestCase( - GmpGetScanConfigNvtsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetCertBundListTestCase( - GmpGetCertBundListTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetCpeListTestCase(GmpGetCpeListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetCveListTestCase(GmpGetCveListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetDfnCertListCase(GmpGetDfnCertListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetNvtListTestCase(GmpGetNvtListTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetOvalDefListTestCase( - GmpGetOvalDefListTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_secinfo.py.rej b/tests/protocols/gmpv208/entities/test_secinfo.py.rej deleted file mode 100644 index 87e727aed..000000000 --- a/tests/protocols/gmpv208/entities/test_secinfo.py.rej +++ /dev/null @@ -1,7 +0,0 @@ -diff a/tests/protocols/gmpv208/entities/test_secinfo.py b/tests/protocols/gmpv208/entities/test_secinfo.py (rejected hunks) -@@ -74 +74,4 @@ class Gmpv208GetNvtTestCase(GmpGetNvtTestMixin, Gmpv208TestCase): --class Gmpv208GetNvtPreferenceTestCase(GmpGetNvtPreferenceTestMixin, Gmpv208TestCase): -+ -+class Gmpv208GetNvtPreferenceTestCase( -+ GmpGetNvtPreferenceTestMixin, Gmpv208TestCase -+): diff --git a/tests/protocols/gmpv208/entities/test_tags.py b/tests/protocols/gmpv208/entities/test_tags.py deleted file mode 100644 index 386db9e2e..000000000 --- a/tests/protocols/gmpv208/entities/test_tags.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .tags import ( - GmpCloneTagTestMixin, - GmpCreateTagTestMixin, - GmpDeleteTagTestMixin, - GmpGetTagsTestMixin, - GmpGetTagTestMixin, - GmpModifyTagTestMixin, -) - - -class Gmpv208DeleteTagTestCase(GmpDeleteTagTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTagTestCase(GmpGetTagTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTagsTestCase(GmpGetTagsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneTagTestCase(GmpCloneTagTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateTagTestCase(GmpCreateTagTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyTagTestCase(GmpModifyTagTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_targets.py b/tests/protocols/gmpv208/entities/test_targets.py deleted file mode 100644 index 6385d6f4c..000000000 --- a/tests/protocols/gmpv208/entities/test_targets.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .targets import ( - GmpCloneTargetTestMixin, - GmpCreateTargetTestMixin, - GmpDeleteTargetTestMixin, - GmpGetTargetsTestMixin, - GmpGetTargetTestMixin, - GmpModifyTargetTestMixin, -) - - -class Gmpv208CloneTargetTestCase(GmpCloneTargetTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateTargetTestCase(GmpCreateTargetTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteTargetTestCase(GmpDeleteTargetTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTargetTestCase(GmpGetTargetTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTargetsTestCase(GmpGetTargetsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyTargetTestCase(GmpModifyTargetTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_tasks.py b/tests/protocols/gmpv208/entities/test_tasks.py deleted file mode 100644 index 0f5bfa8ea..000000000 --- a/tests/protocols/gmpv208/entities/test_tasks.py +++ /dev/null @@ -1,65 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .tasks import ( - GmpCloneTaskTestMixin, - GmpCreateContainerTaskTestMixin, - GmpCreateTaskTestMixin, - GmpDeleteTaskTestMixin, - GmpGetTasksTestMixin, - GmpGetTaskTestMixin, - GmpModifyTaskTestMixin, - GmpMoveTaskTestMixin, - GmpResumeTaskTestMixin, - GmpStartTaskTestMixin, - GmpStopTaskTestMixin, -) - - -class Gmpv208CloneTaskTestCase(GmpCloneTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateContainerTaskTestCase( - GmpCreateContainerTaskTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreateTaskTestCase(GmpCreateTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DeleteTaskTestCase(GmpDeleteTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTaskTestCase(GmpGetTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTasksTestCase(GmpGetTasksTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyTaskTestCase(GmpModifyTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208MoveTaskTestCase(GmpMoveTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ResumeTaskTestCase(GmpResumeTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208StartTaskTestCase(GmpStartTaskTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208StopTaskTestCase(GmpStopTaskTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_tickets.py b/tests/protocols/gmpv208/entities/test_tickets.py deleted file mode 100644 index 01d0c5844..000000000 --- a/tests/protocols/gmpv208/entities/test_tickets.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .tickets import ( - GmpCloneTicketTestMixin, - GmpCreateTicketTestMixin, - GmpDeleteTicketTestMixin, - GmpGetTicketsTestMixin, - GmpGetTicketTestMixin, - GmpModifyTicketTestMixin, -) - - -class Gmpv208DeleteTicketTestCase(GmpDeleteTicketTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTicketTestCase(GmpGetTicketTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetTicketsTestCase(GmpGetTicketsTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneTicketTestCase(GmpCloneTicketTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateTicketTestCase(GmpCreateTicketTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyTicketTestCase(GmpModifyTicketTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_tls_certificates.py b/tests/protocols/gmpv208/entities/test_tls_certificates.py deleted file mode 100644 index ee136f4e1..000000000 --- a/tests/protocols/gmpv208/entities/test_tls_certificates.py +++ /dev/null @@ -1,50 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .tls_certificates import ( - GmpCloneTLSCertificateTestMixin, - GmpCreateTLSCertificateTestMixin, - GmpDeleteTLSCertificateTestMixin, - GmpGetTLSCertificatesTestMixin, - GmpGetTLSCertificateTestMixin, - GmpModifyTLSCertificateTestMixin, -) - - -class Gmpv208CloneTLSCertificateTestCase( - GmpCloneTLSCertificateTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208CreateTLSCertificateTestCase( - GmpCreateTLSCertificateTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208DeleteTLSCertificateTestCase( - GmpDeleteTLSCertificateTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetTLSCertificateTestCase( - GmpGetTLSCertificateTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetTLSCertificatesTestCase( - GmpGetTLSCertificatesTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyTLSCertificateTestCase( - GmpModifyTLSCertificateTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/test_users.py b/tests/protocols/gmpv208/entities/test_users.py deleted file mode 100644 index 1a0daa821..000000000 --- a/tests/protocols/gmpv208/entities/test_users.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .users import ( - GmpCloneUserTestMixin, - GmpCreateUserTestMixin, - GmpDeleteUserTestMixin, - GmpGetUsersTestMixin, - GmpGetUserTestMixin, - GmpModifyUserTestMixin, -) - - -class Gmpv208DeleteUserTestCase(GmpDeleteUserTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetUserTestCase(GmpGetUserTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetUsersTestCase(GmpGetUsersTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CloneUserTestCase(GmpCloneUserTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208CreateUserTestCase(GmpCreateUserTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyUserTestCase(GmpModifyUserTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/entities/test_vulnerabilities.py b/tests/protocols/gmpv208/entities/test_vulnerabilities.py deleted file mode 100644 index 286abaf5b..000000000 --- a/tests/protocols/gmpv208/entities/test_vulnerabilities.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .vulnerabilities import ( - GmpGetVulnerabilitiesTestMixin, - GmpGetVulnerabilityTestMixin, -) - - -class Gmpv208GetVulnerabilityTestCase( - GmpGetVulnerabilityTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetVulnerabilitiesTestCase( - GmpGetVulnerabilitiesTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/entities/users/__init__.py b/tests/protocols/gmpv208/entities/users/__init__.py deleted file mode 100644 index 6a5ca3168..000000000 --- a/tests/protocols/gmpv208/entities/users/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_clone_user import GmpCloneUserTestMixin -from .test_create_user import GmpCreateUserTestMixin -from .test_delete_user import GmpDeleteUserTestMixin -from .test_get_user import GmpGetUserTestMixin -from .test_get_users import GmpGetUsersTestMixin -from .test_modify_user import GmpModifyUserTestMixin - -__all__ = ( - "GmpCloneUserTestMixin", - "GmpCreateUserTestMixin", - "GmpDeleteUserTestMixin", - "GmpGetUserTestMixin", - "GmpGetUsersTestMixin", - "GmpModifyUserTestMixin", -) diff --git a/tests/protocols/gmpv208/entities/users/test_create_user.py b/tests/protocols/gmpv208/entities/users/test_create_user.py deleted file mode 100644 index 0b2fcb388..000000000 --- a/tests/protocols/gmpv208/entities/users/test_create_user.py +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument - - -class GmpCreateUserTestMixin: - def test_create_user_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_user(name=None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_user(name="") - - def test_create_user(self): - self.gmp.create_user(name="foo") - - self.connection.send.has_been_called_with( - "foo" - ) - - def test_create_user_with_password(self): - self.gmp.create_user(name="foo", password="bar") - - self.connection.send.has_been_called_with( - "" - "foo" - "bar" - "" - ) - - def test_create_user_with_hosts(self): - self.gmp.create_user(name="foo", hosts=["h1", "h2"], hosts_allow=True) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - self.gmp.create_user(name="foo", hosts=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - self.gmp.create_user(name="foo", hosts=["h1", "h2"], hosts_allow=False) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - def test_create_user_with_ifaces(self): - self.gmp.create_user(name="foo", ifaces=["h1", "h2"], ifaces_allow=True) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - self.gmp.create_user(name="foo", ifaces=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - self.gmp.create_user( - name="foo", ifaces=["h1", "h2"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - def test_create_user_with_role_ids(self): - self.gmp.create_user(name="foo", role_ids=["r1", "r2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) diff --git a/tests/protocols/gmpv208/entities/users/test_modify_user.py b/tests/protocols/gmpv208/entities/users/test_modify_user.py deleted file mode 100644 index 19b3f5189..000000000 --- a/tests/protocols/gmpv208/entities/users/test_modify_user.py +++ /dev/null @@ -1,203 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208 import UserAuthType - - -class GmpModifyUserTestMixin: - def test_modify_user(self): - self.gmp.modify_user(user_id="u1") - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(name="u1") - - self.connection.send.has_been_called_with( - "u1" - ) - - def test_modify_user_missing_user_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(user_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(user_id="") - - def test_modify_user_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(name=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(name="") - - def test_modify_user_with_new_name(self): - self.gmp.modify_user(user_id="u1", new_name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_new_comment(self): - self.gmp.modify_user(user_id="u1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_user_id_and_name(self): - self.gmp.modify_user(user_id="u1", name="foo") - - self.connection.send.has_been_called_with('') - - def test_modify_user_with_role_ids(self): - self.gmp.modify_user(user_id="u1", role_ids=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", role_ids=["r1"]) - - self.connection.send.has_been_called_with( - '' - ) - - self.gmp.modify_user(user_id="u1", role_ids=["r1", "r2"]) - - self.connection.send.has_been_called_with( - '' - '' - '' - "" - ) - - def test_modify_user_with_group_ids(self): - self.gmp.modify_user(user_id="u1", role_ids=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", group_ids=["r1"]) - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - self.gmp.modify_user(user_id="u1", group_ids=["r1", "r2"]) - - self.connection.send.has_been_called_with( - '' - "" - '' - '' - "" - "" - ) - - def test_modify_user_with_password(self): - self.gmp.modify_user(user_id="u1", password="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_auth_source(self): - self.gmp.modify_user( - user_id="u1", auth_source=UserAuthType.LDAP_CONNECT - ) - - self.connection.send.has_been_called_with( - '' - "ldap_connect" - "" - ) - - def test_modify_user_with_hosts(self): - self.gmp.modify_user(user_id="u1", hosts=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - 'foo' - "" - ) - - self.gmp.modify_user(user_id="u1", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", hosts=["foo", "bar"], hosts_allow=False - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", hosts=["foo", "bar"], hosts_allow=True - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - def test_modify_user_with_ifaces(self): - self.gmp.modify_user(user_id="u1", ifaces=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", ifaces=["foo"]) - - self.connection.send.has_been_called_with( - '' - 'foo' - "" - ) - - self.gmp.modify_user(user_id="u1", ifaces=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", ifaces=["foo", "bar"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", ifaces=["foo", "bar"], ifaces_allow=True - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) diff --git a/tests/protocols/gmpv208/enums/__init__.py b/tests/protocols/gmpv208/enums/__init__.py deleted file mode 100644 index 9104ba9ff..000000000 --- a/tests/protocols/gmpv208/enums/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv208/enums/test_aggregate_statistic.py b/tests/protocols/gmpv208/enums/test_aggregate_statistic.py deleted file mode 100644 index d1fafae9e..000000000 --- a/tests/protocols/gmpv208/enums/test_aggregate_statistic.py +++ /dev/null @@ -1,61 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AggregateStatistic - - -class GetAggregateStatisticFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AggregateStatistic.from_string("foo") - - def test_none_or_empty(self): - ct = AggregateStatistic.from_string(None) - self.assertIsNone(ct) - ct = AggregateStatistic.from_string("") - self.assertIsNone(ct) - - def test_count(self): - ct = AggregateStatistic.from_string("count") - self.assertEqual(ct, AggregateStatistic.COUNT) - - def test_c_count(self): - ct = AggregateStatistic.from_string("c_count") - self.assertEqual(ct, AggregateStatistic.C_COUNT) - - def test_c_sum(self): - ct = AggregateStatistic.from_string("c_sum") - self.assertEqual(ct, AggregateStatistic.C_SUM) - - def test_max(self): - ct = AggregateStatistic.from_string("max") - self.assertEqual(ct, AggregateStatistic.MAX) - - def test_mean(self): - ct = AggregateStatistic.from_string("mean") - self.assertEqual(ct, AggregateStatistic.MEAN) - - def test_min(self): - ct = AggregateStatistic.from_string("min") - self.assertEqual(ct, AggregateStatistic.MIN) - - def test_sum(self): - ct = AggregateStatistic.from_string("sum") - self.assertEqual(ct, AggregateStatistic.SUM) - - def test_text(self): - ct = AggregateStatistic.from_string("text") - self.assertEqual(ct, AggregateStatistic.TEXT) - - def test_value(self): - ct = AggregateStatistic.from_string("value") - self.assertEqual(ct, AggregateStatistic.VALUE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_alert_condition.py b/tests/protocols/gmpv208/enums/test_alert_condition.py deleted file mode 100644 index 424673177..000000000 --- a/tests/protocols/gmpv208/enums/test_alert_condition.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AlertCondition - - -class GetAlertConditionFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertCondition.from_string("foo") - - def test_none_or_empty(self): - ct = AlertCondition.from_string(None) - self.assertIsNone(ct) - ct = AlertCondition.from_string("") - self.assertIsNone(ct) - - def test_always(self): - ct = AlertCondition.from_string("always") - self.assertEqual(ct, AlertCondition.ALWAYS) - - def test_filter_count_at_least(self): - ct = AlertCondition.from_string("filter count at least") - self.assertEqual(ct, AlertCondition.FILTER_COUNT_AT_LEAST) - - def test_filter_count_changed(self): - ct = AlertCondition.from_string("filter count changed") - self.assertEqual(ct, AlertCondition.FILTER_COUNT_CHANGED) - - def test_severity_at_least(self): - ct = AlertCondition.from_string("severity at least") - self.assertEqual(ct, AlertCondition.SEVERITY_AT_LEAST) - - def test_severity_changed(self): - ct = AlertCondition.from_string("severity changed") - self.assertEqual(ct, AlertCondition.SEVERITY_CHANGED) - - def test_error(self): - ct = AlertCondition.from_string("error") - self.assertEqual(ct, AlertCondition.ERROR) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_alert_event.py b/tests/protocols/gmpv208/enums/test_alert_event.py deleted file mode 100644 index bb8eb37d3..000000000 --- a/tests/protocols/gmpv208/enums/test_alert_event.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AlertEvent - - -class GetAlertEventFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertEvent.from_string("foo") - - def test_none_or_empty(self): - ct = AlertEvent.from_string(None) - self.assertIsNone(ct) - ct = AlertEvent.from_string("") - self.assertIsNone(ct) - - def test_task_run_status_changed(self): - ct = AlertEvent.from_string("Task run status changed") - self.assertEqual(ct, AlertEvent.TASK_RUN_STATUS_CHANGED) - - def test_new_secinfo_arrived(self): - ct = AlertEvent.from_string("New SecInfo arrived") - self.assertEqual(ct, AlertEvent.NEW_SECINFO_ARRIVED) - - def test_updated_secinfo_arrived(self): - ct = AlertEvent.from_string("Updated SecInfo arrived") - self.assertEqual(ct, AlertEvent.UPDATED_SECINFO_ARRIVED) - - def test_ticket_received(self): - ct = AlertEvent.from_string("ticket received") - self.assertEqual(ct, AlertEvent.TICKET_RECEIVED) - - def test_assigned_ticket_changed(self): - ct = AlertEvent.from_string("assigned ticket changed") - self.assertEqual(ct, AlertEvent.ASSIGNED_TICKET_CHANGED) - - def test_owned_ticket_changed(self): - ct = AlertEvent.from_string("owned ticket changed") - self.assertEqual(ct, AlertEvent.OWNED_TICKET_CHANGED) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_alert_method.py b/tests/protocols/gmpv208/enums/test_alert_method.py deleted file mode 100644 index 161f42b9a..000000000 --- a/tests/protocols/gmpv208/enums/test_alert_method.py +++ /dev/null @@ -1,73 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AlertMethod - - -class GetAlertMethodFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertMethod.from_string("foo") - - def test_none_or_empty(self): - ct = AlertMethod.from_string(None) - self.assertIsNone(ct) - ct = AlertMethod.from_string("") - self.assertIsNone(ct) - - def test_email(self): - ct = AlertMethod.from_string("email") - self.assertEqual(ct, AlertMethod.EMAIL) - - def test_scp(self): - ct = AlertMethod.from_string("scp") - self.assertEqual(ct, AlertMethod.SCP) - - def test_send(self): - ct = AlertMethod.from_string("send") - self.assertEqual(ct, AlertMethod.SEND) - - def test_smb(self): - ct = AlertMethod.from_string("smb") - self.assertEqual(ct, AlertMethod.SMB) - - def test_snmp(self): - ct = AlertMethod.from_string("snmp") - self.assertEqual(ct, AlertMethod.SNMP) - - def test_syslog(self): - ct = AlertMethod.from_string("syslog") - self.assertEqual(ct, AlertMethod.SYSLOG) - - def test_http_get(self): - ct = AlertMethod.from_string("HTTP Get") - self.assertEqual(ct, AlertMethod.HTTP_GET) - - def test_start_task(self): - ct = AlertMethod.from_string("Start Task") - self.assertEqual(ct, AlertMethod.START_TASK) - - def test_sourcefire_connector(self): - ct = AlertMethod.from_string("sourcefire Connector") - self.assertEqual(ct, AlertMethod.SOURCEFIRE_CONNECTOR) - - def test_verinice_connector(self): - ct = AlertMethod.from_string("verinice Connector") - self.assertEqual(ct, AlertMethod.VERINICE_CONNECTOR) - - def test_tippingpoint_sms(self): - ct = AlertMethod.from_string("Tippingpoint SMS") - self.assertEqual(ct, AlertMethod.TIPPINGPOINT_SMS) - - def test_alemba_vfire(self): - ct = AlertMethod.from_string("Alemba vFire") - self.assertEqual(ct, AlertMethod.ALEMBA_VFIRE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_alive_test.py b/tests/protocols/gmpv208/enums/test_alive_test.py deleted file mode 100644 index 5c0a722ec..000000000 --- a/tests/protocols/gmpv208/enums/test_alive_test.py +++ /dev/null @@ -1,65 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AliveTest - - -class GetAliveTestFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AliveTest.from_string("foo") - - def test_none_or_empty(self): - ct = AliveTest.from_string(None) - self.assertIsNone(ct) - ct = AliveTest.from_string("") - self.assertIsNone(ct) - - def test_scan_config_default(self): - ct = AliveTest.from_string("Scan Config Default") - self.assertEqual(ct, AliveTest.SCAN_CONFIG_DEFAULT) - - def test_icmp_ping(self): - ct = AliveTest.from_string("ICMP Ping") - self.assertEqual(ct, AliveTest.ICMP_PING) - - def test_tcp_ack_service_ping(self): - ct = AliveTest.from_string("TCP-ACK Service Ping") - self.assertEqual(ct, AliveTest.TCP_ACK_SERVICE_PING) - - def test_tcp_sync_service_ping(self): - ct = AliveTest.from_string("TCP-SYN Service Ping") - self.assertEqual(ct, AliveTest.TCP_SYN_SERVICE_PING) - - def test_arp_ping(self): - ct = AliveTest.from_string("ARP Ping") - self.assertEqual(ct, AliveTest.ARP_PING) - - def test_icmp_and_tcp_ack_service_ping(self): - ct = AliveTest.from_string("ICMP & TCP-ACK Service Ping") - self.assertEqual(ct, AliveTest.ICMP_AND_TCP_ACK_SERVICE_PING) - - def test_icmp_and_arp_ping(self): - ct = AliveTest.from_string("ICMP & ARP Ping") - self.assertEqual(ct, AliveTest.ICMP_AND_ARP_PING) - - def test_tcp_ack_service_and_arp_ping(self): - ct = AliveTest.from_string("TCP-ACK Service & ARP Ping") - self.assertEqual(ct, AliveTest.TCP_ACK_SERVICE_AND_ARP_PING) - - def test_icmp_tcp_ack_service_and_arp_ping(self): - ct = AliveTest.from_string("ICMP, TCP-ACK Service & ARP Ping") - self.assertEqual(ct, AliveTest.ICMP_TCP_ACK_SERVICE_AND_ARP_PING) - - def test_consider_alive(self): - ct = AliveTest.from_string("Consider Alive") - self.assertEqual(ct, AliveTest.CONSIDER_ALIVE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_credential_format.py b/tests/protocols/gmpv208/enums/test_credential_format.py deleted file mode 100644 index c91b67e62..000000000 --- a/tests/protocols/gmpv208/enums/test_credential_format.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import CredentialFormat - - -class GetCredentialFromatFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - CredentialFormat.from_string("foo") - - def test_none_or_empty(self): - ct = CredentialFormat.from_string(None) - self.assertIsNone(ct) - ct = CredentialFormat.from_string("") - self.assertIsNone(ct) - - def test_key(self): - ct = CredentialFormat.from_string("key") - self.assertEqual(ct, CredentialFormat.KEY) - - def test_rpm(self): - ct = CredentialFormat.from_string("rpm") - self.assertEqual(ct, CredentialFormat.RPM) - - def test_deb(self): - ct = CredentialFormat.from_string("deb") - self.assertEqual(ct, CredentialFormat.DEB) - - def test_exe(self): - ct = CredentialFormat.from_string("exe") - self.assertEqual(ct, CredentialFormat.EXE) - - def test_pem(self): - ct = CredentialFormat.from_string("pem") - self.assertEqual(ct, CredentialFormat.PEM) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_credential_type.py b/tests/protocols/gmpv208/enums/test_credential_type.py deleted file mode 100644 index 47fa6c022..000000000 --- a/tests/protocols/gmpv208/enums/test_credential_type.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import CredentialType - - -class GetCredentialTypeFromStringTestCase(unittest.TestCase): - def test_invalid_type(self): - with self.assertRaises(InvalidArgument): - CredentialType.from_string("foo") - - def test_none_or_empty_type(self): - ct = CredentialType.from_string(None) - self.assertIsNone(ct) - ct = CredentialType.from_string("") - self.assertIsNone(ct) - - def test_client_certificate(self): - ct = CredentialType.from_string("client_certificate") - self.assertEqual(ct, CredentialType.CLIENT_CERTIFICATE) - - def test_snmp(self): - ct = CredentialType.from_string("snmp") - self.assertEqual(ct, CredentialType.SNMP) - - def test_username_password(self): - ct = CredentialType.from_string("username_password") - self.assertEqual(ct, CredentialType.USERNAME_PASSWORD) - - def test_username_ssh_key(self): - ct = CredentialType.from_string("username_ssh_key") - self.assertEqual(ct, CredentialType.USERNAME_SSH_KEY) - - def test_smime_certificate(self): - ct = CredentialType.from_string("smime_certificate") - self.assertEqual(ct, CredentialType.SMIME_CERTIFICATE) - - def test_pgp_encryption_key(self): - ct = CredentialType.from_string("pgp_encryption_key") - self.assertEqual(ct, CredentialType.PGP_ENCRYPTION_KEY) - - def test_password_only(self): - ct = CredentialType.from_string("password_only") - self.assertEqual(ct, CredentialType.PASSWORD_ONLY) diff --git a/tests/protocols/gmpv208/enums/test_entity_type.py b/tests/protocols/gmpv208/enums/test_entity_type.py deleted file mode 100644 index e9eda8a62..000000000 --- a/tests/protocols/gmpv208/enums/test_entity_type.py +++ /dev/null @@ -1,166 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import EntityType - - -class GetEntityTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - EntityType.from_string("foo") - - def test_none_or_empty(self): - ct = EntityType.from_string(None) - self.assertIsNone(ct) - ct = EntityType.from_string("") - self.assertIsNone(ct) - - def test_alert(self): - ct = EntityType.from_string("alert") - self.assertEqual(ct, EntityType.ALERT) - - def test_asset(self): - ct = EntityType.from_string("asset") - self.assertEqual(ct, EntityType.ASSET) - - def test_audit(self): - ct = EntityType.from_string("audit") - self.assertEqual(ct, EntityType.AUDIT) - - def test_cert_bund_adv(self): - ct = EntityType.from_string("cert_bund_adv") - self.assertEqual(ct, EntityType.CERT_BUND_ADV) - - def test_cpe(self): - ct = EntityType.from_string("cpe") - self.assertEqual(ct, EntityType.CPE) - - def test_credential(self): - ct = EntityType.from_string("credential") - self.assertEqual(ct, EntityType.CREDENTIAL) - - def test_dfn_cert_adv(self): - ct = EntityType.from_string("dfn_cert_adv") - self.assertEqual(ct, EntityType.DFN_CERT_ADV) - - def test_filter(self): - ct = EntityType.from_string("filter") - self.assertEqual(ct, EntityType.FILTER) - - def test_group(self): - ct = EntityType.from_string("group") - self.assertEqual(ct, EntityType.GROUP) - - def test_host(self): - ct = EntityType.from_string("host") - self.assertEqual(ct, EntityType.HOST) - - def test_info(self): - ct = EntityType.from_string("info") - self.assertEqual(ct, EntityType.INFO) - - def test_note(self): - ct = EntityType.from_string("note") - self.assertEqual(ct, EntityType.NOTE) - - def test_nvt(self): - ct = EntityType.from_string("nvt") - self.assertEqual(ct, EntityType.NVT) - - def test_operating_system(self): - ct = EntityType.from_string("os") - self.assertEqual(ct, EntityType.OPERATING_SYSTEM) - - ct = EntityType.from_string("operating_system") - self.assertEqual(ct, EntityType.OPERATING_SYSTEM) - - def test_ovaldef(self): - ct = EntityType.from_string("ovaldef") - self.assertEqual(ct, EntityType.OVALDEF) - - def test_override(self): - ct = EntityType.from_string("override") - self.assertEqual(ct, EntityType.OVERRIDE) - - def test_permission(self): - ct = EntityType.from_string("permission") - self.assertEqual(ct, EntityType.PERMISSION) - - def test_policy(self): - ct = EntityType.from_string("policy") - self.assertEqual(ct, EntityType.POLICY) - - def test_port_list(self): - ct = EntityType.from_string("port_list") - self.assertEqual(ct, EntityType.PORT_LIST) - - def test_report(self): - ct = EntityType.from_string("report") - self.assertEqual(ct, EntityType.REPORT) - - def test_report_format(self): - ct = EntityType.from_string("report_format") - self.assertEqual(ct, EntityType.REPORT_FORMAT) - - def test_result(self): - ct = EntityType.from_string("result") - self.assertEqual(ct, EntityType.RESULT) - - def test_role(self): - ct = EntityType.from_string("role") - self.assertEqual(ct, EntityType.ROLE) - - def test_scan_config(self): - ct = EntityType.from_string("config") - self.assertEqual(ct, EntityType.SCAN_CONFIG) - - ct = EntityType.from_string("scan_config") - self.assertEqual(ct, EntityType.SCAN_CONFIG) - - def test_scanner(self): - ct = EntityType.from_string("scanner") - self.assertEqual(ct, EntityType.SCANNER) - - def test_schedule(self): - ct = EntityType.from_string("schedule") - self.assertEqual(ct, EntityType.SCHEDULE) - - def test_tag(self): - ct = EntityType.from_string("tag") - self.assertEqual(ct, EntityType.TAG) - - def test_target(self): - ct = EntityType.from_string("target") - self.assertEqual(ct, EntityType.TARGET) - - def test_task(self): - ct = EntityType.from_string("task") - self.assertEqual(ct, EntityType.TASK) - - def test_ticket(self): - ct = EntityType.from_string("ticket") - self.assertEqual(ct, EntityType.TICKET) - - def test_tls_certificate(self): - ft = EntityType.from_string("tls_certificate") - self.assertEqual(ft, EntityType.TLS_CERTIFICATE) - - def test_user(self): - ct = EntityType.from_string("user") - self.assertEqual(ct, EntityType.USER) - - def test_vulnerability(self): - ct = EntityType.from_string("vuln") - self.assertEqual(ct, EntityType.VULNERABILITY) - - ct = EntityType.from_string("vulnerability") - self.assertEqual(ct, EntityType.VULNERABILITY) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_feed_type.py b/tests/protocols/gmpv208/enums/test_feed_type.py deleted file mode 100644 index 929a6735d..000000000 --- a/tests/protocols/gmpv208/enums/test_feed_type.py +++ /dev/null @@ -1,41 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import FeedType - - -class GetFeedTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - FeedType.from_string("foo") - - def test_none_or_empty(self): - ct = FeedType.from_string(None) - self.assertIsNone(ct) - ct = FeedType.from_string("") - self.assertIsNone(ct) - - def test_nvt(self): - ct = FeedType.from_string("nvt") - self.assertEqual(ct, FeedType.NVT) - - def test_cert(self): - ct = FeedType.from_string("cert") - self.assertEqual(ct, FeedType.CERT) - - def test_scap(self): - ct = FeedType.from_string("scap") - self.assertEqual(ct, FeedType.SCAP) - - def test_gvmd_data(self): - ct = FeedType.from_string("gvmd_data") - self.assertEqual(ct, FeedType.GVMD_DATA) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_filter_type.py b/tests/protocols/gmpv208/enums/test_filter_type.py deleted file mode 100644 index 474b91fe6..000000000 --- a/tests/protocols/gmpv208/enums/test_filter_type.py +++ /dev/null @@ -1,138 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import FilterType - - -class GetFilterTypeFomStringTestCase(unittest.TestCase): - def test_filter_type_alert(self): - ft = FilterType.from_string("alert") - self.assertEqual(ft, FilterType.ALERT) - - def test_filter_type_asset(self): - ft = FilterType.from_string("asset") - self.assertEqual(ft, FilterType.ASSET) - - def test_filter_type_credential(self): - ft = FilterType.from_string("credential") - self.assertEqual(ft, FilterType.CREDENTIAL) - - def test_filter_type_filter(self): - ft = FilterType.from_string("filter") - self.assertEqual(ft, FilterType.FILTER) - - def test_filter_type_group(self): - ft = FilterType.from_string("group") - self.assertEqual(ft, FilterType.GROUP) - - def test_filter_type_host(self): - ft = FilterType.from_string("host") - self.assertEqual(ft, FilterType.HOST) - - def test_filter_type_note(self): - ft = FilterType.from_string("note") - self.assertEqual(ft, FilterType.NOTE) - - def test_filter_type_override(self): - ft = FilterType.from_string("override") - self.assertEqual(ft, FilterType.OVERRIDE) - - def test_filter_type_permission(self): - ft = FilterType.from_string("permission") - self.assertEqual(ft, FilterType.PERMISSION) - - def test_filter_type_port_list(self): - ft = FilterType.from_string("port_list") - self.assertEqual(ft, FilterType.PORT_LIST) - - def test_filter_type_report(self): - ft = FilterType.from_string("report") - self.assertEqual(ft, FilterType.REPORT) - - def test_filter_type_report_format(self): - ft = FilterType.from_string("report_format") - self.assertEqual(ft, FilterType.REPORT_FORMAT) - - def test_filter_type_result(self): - ft = FilterType.from_string("result") - self.assertEqual(ft, FilterType.RESULT) - - def test_filter_type_role(self): - ft = FilterType.from_string("role") - self.assertEqual(ft, FilterType.ROLE) - - def test_filter_type_schedule(self): - ft = FilterType.from_string("schedule") - self.assertEqual(ft, FilterType.SCHEDULE) - - def test_filter_type_secinfo(self): - ft = FilterType.from_string("secinfo") - self.assertEqual(ft, FilterType.ALL_SECINFO) - - def test_filter_type_all_secinfo(self): - ft = FilterType.from_string("all_secinfo") - self.assertEqual(ft, FilterType.ALL_SECINFO) - - def test_filter_type_tag(self): - ft = FilterType.from_string("tag") - self.assertEqual(ft, FilterType.TAG) - - def test_filter_type_task(self): - ft = FilterType.from_string("task") - self.assertEqual(ft, FilterType.TASK) - - def test_filter_type_target(self): - ft = FilterType.from_string("target") - self.assertEqual(ft, FilterType.TARGET) - - def test_filter_type_ticket(self): - ft = FilterType.from_string("ticket") - self.assertEqual(ft, FilterType.TICKET) - - def test_filter_type_tls_certificate(self): - ft = FilterType.from_string("tls_certificate") - self.assertEqual(ft, FilterType.TLS_CERTIFICATE) - - def test_filter_type_operating_system(self): - ft = FilterType.from_string("operating_system") - self.assertEqual(ft, FilterType.OPERATING_SYSTEM) - - def test_filter_type_user(self): - ft = FilterType.from_string("user") - self.assertEqual(ft, FilterType.USER) - - def test_filter_type_vuln(self): - ft = FilterType.from_string("vuln") - self.assertEqual(ft, FilterType.VULNERABILITY) - - def test_filter_type_vulnerability(self): - ft = FilterType.from_string("vulnerability") - self.assertEqual(ft, FilterType.VULNERABILITY) - - def test_filter_type_config(self): - ft = FilterType.from_string("config") - self.assertEqual(ft, FilterType.SCAN_CONFIG) - - def test_filter_type_scan_config(self): - ft = FilterType.from_string("scan_config") - self.assertEqual(ft, FilterType.SCAN_CONFIG) - - def test_filter_type_os(self): - ft = FilterType.from_string("os") - self.assertEqual(ft, FilterType.OPERATING_SYSTEM) - - def test_invalid_filter_type(self): - with self.assertRaises(InvalidArgument): - FilterType.from_string("foo") - - def test_non_or_empty_filter_type(self): - ft = FilterType.from_string(None) - self.assertIsNone(ft) - - ft = FilterType.from_string("") - self.assertIsNone(ft) diff --git a/tests/protocols/gmpv208/enums/test_help_format.py b/tests/protocols/gmpv208/enums/test_help_format.py deleted file mode 100644 index 2627da1fd..000000000 --- a/tests/protocols/gmpv208/enums/test_help_format.py +++ /dev/null @@ -1,41 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import HelpFormat - - -class GetHelpFormatFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - HelpFormat.from_string("foo") - - def test_none_or_empty(self): - ct = HelpFormat.from_string(None) - self.assertIsNone(ct) - ct = HelpFormat.from_string("") - self.assertIsNone(ct) - - def test_task_run_status_changed(self): - ct = HelpFormat.from_string("HtMl") - self.assertEqual(ct, HelpFormat.HTML) - - def test_new_secinfo_arrived(self): - ct = HelpFormat.from_string("rNc") - self.assertEqual(ct, HelpFormat.RNC) - - def test_updated_secinfo_arrived(self): - ct = HelpFormat.from_string("tExT") - self.assertEqual(ct, HelpFormat.TEXT) - - def test_ticket_received(self): - ct = HelpFormat.from_string("XmL") - self.assertEqual(ct, HelpFormat.XML) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_hosts_ordering.py b/tests/protocols/gmpv208/enums/test_hosts_ordering.py deleted file mode 100644 index fc5f2e9e8..000000000 --- a/tests/protocols/gmpv208/enums/test_hosts_ordering.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import HostsOrdering - - -class GetHostsOrderingFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - HostsOrdering.from_string("foo") - - def test_none_or_empty(self): - ct = HostsOrdering.from_string(None) - self.assertIsNone(ct) - ct = HostsOrdering.from_string("") - self.assertIsNone(ct) - - def test_sequential(self): - ct = HostsOrdering.from_string("sequential") - self.assertEqual(ct, HostsOrdering.SEQUENTIAL) - - def test_random(self): - ct = HostsOrdering.from_string("random") - self.assertEqual(ct, HostsOrdering.RANDOM) - - def test_reverse(self): - ct = HostsOrdering.from_string("reverse") - self.assertEqual(ct, HostsOrdering.REVERSE) diff --git a/tests/protocols/gmpv208/enums/test_info_type.py b/tests/protocols/gmpv208/enums/test_info_type.py deleted file mode 100644 index f5547a8ff..000000000 --- a/tests/protocols/gmpv208/enums/test_info_type.py +++ /dev/null @@ -1,53 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import InfoType - - -class GetInfoTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - InfoType.from_string("foo") - - def test_none_or_empty(self): - ct = InfoType.from_string(None) - self.assertIsNone(ct) - ct = InfoType.from_string("") - self.assertIsNone(ct) - - def test_cert_bund_adv(self): - ct = InfoType.from_string("cert_bund_adv") - self.assertEqual(ct, InfoType.CERT_BUND_ADV) - - def test_cpe(self): - ct = InfoType.from_string("cpe") - self.assertEqual(ct, InfoType.CPE) - - def test_cve(self): - ct = InfoType.from_string("cve") - self.assertEqual(ct, InfoType.CVE) - - def test_dfn_cert_adv(self): - ct = InfoType.from_string("dfn_cert_adv") - self.assertEqual(ct, InfoType.DFN_CERT_ADV) - - def test_nvt(self): - ct = InfoType.from_string("nvt") - self.assertEqual(ct, InfoType.NVT) - - def test_ovaldef(self): - ct = InfoType.from_string("ovaldef") - self.assertEqual(ct, InfoType.OVALDEF) - - def test_allinfo(self): - with self.assertRaises(InvalidArgument): - InfoType.from_string("allinfo") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_permission_subject_type.py b/tests/protocols/gmpv208/enums/test_permission_subject_type.py deleted file mode 100644 index 34ebd6fcf..000000000 --- a/tests/protocols/gmpv208/enums/test_permission_subject_type.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import PermissionSubjectType - - -class GetPermissionSubjectTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - PermissionSubjectType.from_string("foo") - - def test_none_or_empty(self): - ct = PermissionSubjectType.from_string(None) - self.assertIsNone(ct) - ct = PermissionSubjectType.from_string("") - self.assertIsNone(ct) - - def test_user(self): - ct = PermissionSubjectType.from_string("user") - self.assertEqual(ct, PermissionSubjectType.USER) - - def test_role(self): - ct = PermissionSubjectType.from_string("role") - self.assertEqual(ct, PermissionSubjectType.ROLE) - - def test_group(self): - ct = PermissionSubjectType.from_string("group") - self.assertEqual(ct, PermissionSubjectType.GROUP) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_port_range_type.py b/tests/protocols/gmpv208/enums/test_port_range_type.py deleted file mode 100644 index cd4b1605c..000000000 --- a/tests/protocols/gmpv208/enums/test_port_range_type.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import PortRangeType - - -class GetPortRangeTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - PortRangeType.from_string("foo") - - def test_none_or_empty(self): - ct = PortRangeType.from_string(None) - self.assertIsNone(ct) - ct = PortRangeType.from_string("") - self.assertIsNone(ct) - - def test_tcp(self): - ct = PortRangeType.from_string("tcp") - self.assertEqual(ct, PortRangeType.TCP) - - def test_udp(self): - ct = PortRangeType.from_string("udp") - self.assertEqual(ct, PortRangeType.UDP) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_report_format_type.py b/tests/protocols/gmpv208/enums/test_report_format_type.py deleted file mode 100644 index ed2715843..000000000 --- a/tests/protocols/gmpv208/enums/test_report_format_type.py +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType - - -class GetPortRangeTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - ReportFormatType.from_string("foo") - - def test_none_or_empty(self): - ct = ReportFormatType.from_string(None) - self.assertIsNone(ct) - ct = ReportFormatType.from_string("") - self.assertIsNone(ct) - - def test_anonymous_pdf(self): - ct = ReportFormatType.from_string("anonymous xml") - self.assertEqual(ct, ReportFormatType.ANONYMOUS_XML) - - def test_arf(self): - ct = ReportFormatType.from_string("arf") - self.assertEqual(ct, ReportFormatType.ARF) - - def test_(self): - ct = ReportFormatType.from_string("cpe") - self.assertEqual(ct, ReportFormatType.CPE) - - def test_csv_hosts(self): - ct = ReportFormatType.from_string("csv hosts") - self.assertEqual(ct, ReportFormatType.CSV_HOSTS) - - def test_csv_results(self): - ct = ReportFormatType.from_string("csv results") - self.assertEqual(ct, ReportFormatType.CSV_RESULTS) - - def test_gcr_pdf(self): - ct = ReportFormatType.from_string("gcr pdf") - self.assertEqual(ct, ReportFormatType.GCR_PDF) - - def test_gsr_html(self): - ct = ReportFormatType.from_string("gsr html") - self.assertEqual(ct, ReportFormatType.GSR_HTML) - - def test_gsr_pdf(self): - ct = ReportFormatType.from_string("gsr pdf") - self.assertEqual(ct, ReportFormatType.GSR_PDF) - - def test_gxcr_pdf(self): - ct = ReportFormatType.from_string("gxcr pdf") - self.assertEqual(ct, ReportFormatType.GXCR_PDF) - - def test_gxr_pdf(self): - ct = ReportFormatType.from_string("gxr pdf") - self.assertEqual(ct, ReportFormatType.GXR_PDF) - - def test_itg(self): - ct = ReportFormatType.from_string("itg") - self.assertEqual(ct, ReportFormatType.ITG) - - def test_latex(self): - ct = ReportFormatType.from_string("latex") - self.assertEqual(ct, ReportFormatType.LATEX) - - def test_nbe(self): - ct = ReportFormatType.from_string("nbe") - self.assertEqual(ct, ReportFormatType.NBE) - - def test_pdf(self): - ct = ReportFormatType.from_string("pdf") - self.assertEqual(ct, ReportFormatType.PDF) - - def test_svg(self): - ct = ReportFormatType.from_string("svg") - self.assertEqual(ct, ReportFormatType.SVG) - - def test_txt(self): - ct = ReportFormatType.from_string("txt") - self.assertEqual(ct, ReportFormatType.TXT) - - def test_verinice_ism(self): - ct = ReportFormatType.from_string("verinice ism") - self.assertEqual(ct, ReportFormatType.VERINICE_ISM) - - def test_verinice_itg(self): - ct = ReportFormatType.from_string("verinice itg") - self.assertEqual(ct, ReportFormatType.VERINICE_ITG) - - def test_xml(self): - ct = ReportFormatType.from_string("xml") - self.assertEqual(ct, ReportFormatType.XML) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_scanner_type.py b/tests/protocols/gmpv208/enums/test_scanner_type.py deleted file mode 100644 index 40bad2833..000000000 --- a/tests/protocols/gmpv208/enums/test_scanner_type.py +++ /dev/null @@ -1,60 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import ScannerType - - -class GetScannerTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - ScannerType.from_string("foo") - - def test_none_or_empty(self): - ct = ScannerType.from_string(None) - self.assertIsNone(ct) - ct = ScannerType.from_string("") - self.assertIsNone(ct) - - def test_osp_scanner(self): - ct = ScannerType.from_string("1") - self.assertEqual(ct, ScannerType.OSP_SCANNER_TYPE) - - ct = ScannerType.from_string("osp") - self.assertEqual(ct, ScannerType.OSP_SCANNER_TYPE) - - def test_openvas_scanner(self): - ct = ScannerType.from_string("2") - self.assertEqual(ct, ScannerType.OPENVAS_SCANNER_TYPE) - - ct = ScannerType.from_string("openvas") - self.assertEqual(ct, ScannerType.OPENVAS_SCANNER_TYPE) - - def test_cve_scanner(self): - ct = ScannerType.from_string("3") - self.assertEqual(ct, ScannerType.CVE_SCANNER_TYPE) - - ct = ScannerType.from_string("cve") - self.assertEqual(ct, ScannerType.CVE_SCANNER_TYPE) - - def test_gmp_scanner(self): - ct = ScannerType.from_string("4") - self.assertEqual(ct, ScannerType.GMP_SCANNER_TYPE) - - ct = ScannerType.from_string("gmp") - self.assertEqual(ct, ScannerType.GMP_SCANNER_TYPE) - - def test_greenbone_sensor_scanner(self): - ct = ScannerType.from_string("5") - self.assertEqual(ct, ScannerType.GREENBONE_SENSOR_SCANNER_TYPE) - - ct = ScannerType.from_string("greenbone") - self.assertEqual(ct, ScannerType.GREENBONE_SENSOR_SCANNER_TYPE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_severity_level.py b/tests/protocols/gmpv208/enums/test_severity_level.py deleted file mode 100644 index c1192af7b..000000000 --- a/tests/protocols/gmpv208/enums/test_severity_level.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import SeverityLevel - - -class GetSeverityLevelFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SeverityLevel.from_string("foo") - - def test_none_or_empty(self): - ct = SeverityLevel.from_string(None) - self.assertIsNone(ct) - ct = SeverityLevel.from_string("") - self.assertIsNone(ct) - - def test_high(self): - ct = SeverityLevel.from_string("High") - self.assertEqual(ct, SeverityLevel.HIGH) - - def test_medium(self): - ct = SeverityLevel.from_string("Medium") - self.assertEqual(ct, SeverityLevel.MEDIUM) - - def test_low(self): - ct = SeverityLevel.from_string("Low") - self.assertEqual(ct, SeverityLevel.LOW) - - def test_log(self): - ct = SeverityLevel.from_string("Log") - self.assertEqual(ct, SeverityLevel.LOG) - - def test_alarm(self): - ct = SeverityLevel.from_string("Alarm") - self.assertEqual(ct, SeverityLevel.ALARM) - - def test_debug(self): - ct = SeverityLevel.from_string("Debug") - self.assertEqual(ct, SeverityLevel.DEBUG) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_snmp_algorithms.py b/tests/protocols/gmpv208/enums/test_snmp_algorithms.py deleted file mode 100644 index bae39b35c..000000000 --- a/tests/protocols/gmpv208/enums/test_snmp_algorithms.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import SnmpAuthAlgorithm, SnmpPrivacyAlgorithm - - -class GetSnmpAuthAlgorithmFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - SnmpAuthAlgorithm.from_string("foo") - - def test_none_or_empty_type(self): - ts = SnmpAuthAlgorithm.from_string(None) - self.assertIsNone(ts) - ts = SnmpAuthAlgorithm.from_string("") - self.assertIsNone(ts) - - def test_sha1(self): - ts = SnmpAuthAlgorithm.from_string("sha1") - self.assertEqual(ts, SnmpAuthAlgorithm.SHA1) - - def test_md5(self): - ts = SnmpAuthAlgorithm.from_string("md5") - self.assertEqual(ts, SnmpAuthAlgorithm.MD5) - - -class GetSnmpPrivacyAlgorithmFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - SnmpPrivacyAlgorithm.from_string("foo") - - def test_none_or_empty_type(self): - ts = SnmpPrivacyAlgorithm.from_string(None) - self.assertIsNone(ts) - ts = SnmpPrivacyAlgorithm.from_string("") - self.assertIsNone(ts) - - def test_aes(self): - ts = SnmpPrivacyAlgorithm.from_string("aes") - self.assertEqual(ts, SnmpPrivacyAlgorithm.AES) - - def test_des(self): - ts = SnmpPrivacyAlgorithm.from_string("des") - self.assertEqual(ts, SnmpPrivacyAlgorithm.DES) diff --git a/tests/protocols/gmpv208/enums/test_sort_order.py b/tests/protocols/gmpv208/enums/test_sort_order.py deleted file mode 100644 index 34b675c9b..000000000 --- a/tests/protocols/gmpv208/enums/test_sort_order.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import SortOrder - - -class GetSortOrderFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SortOrder.from_string("foo") - - def test_none_or_empty(self): - ct = SortOrder.from_string(None) - self.assertIsNone(ct) - ct = SortOrder.from_string("") - self.assertIsNone(ct) - - def test_ascending(self): - ct = SortOrder.from_string("ascending") - self.assertEqual(ct, SortOrder.ASCENDING) - - def test_descending(self): - ct = SortOrder.from_string("descending") - self.assertEqual(ct, SortOrder.DESCENDING) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/enums/test_ticket_status.py b/tests/protocols/gmpv208/enums/test_ticket_status.py deleted file mode 100644 index c0ca4bb3c..000000000 --- a/tests/protocols/gmpv208/enums/test_ticket_status.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import TicketStatus - - -class GetTicketStatusFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - TicketStatus.from_string("foo") - - def test_none_or_empty_type(self): - ts = TicketStatus.from_string(None) - self.assertIsNone(ts) - ts = TicketStatus.from_string("") - self.assertIsNone(ts) - - def test_ticket_status_open(self): - ts = TicketStatus.from_string("open") - self.assertEqual(ts, TicketStatus.OPEN) - - def test_ticket_status_fixed(self): - ts = TicketStatus.from_string("fixed") - self.assertEqual(ts, TicketStatus.FIXED) - - def test_ticket_status_closed(self): - ts = TicketStatus.from_string("closed") - self.assertEqual(ts, TicketStatus.CLOSED) diff --git a/tests/protocols/gmpv208/enums/test_user_auth_type.py b/tests/protocols/gmpv208/enums/test_user_auth_type.py deleted file mode 100644 index f572b1433..000000000 --- a/tests/protocols/gmpv208/enums/test_user_auth_type.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import UserAuthType - - -class GetUserAuthTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - UserAuthType.from_string("foo") - - def test_none_or_empty(self): - ct = UserAuthType.from_string(None) - self.assertIsNone(ct) - ct = UserAuthType.from_string("") - self.assertIsNone(ct) - - def test_file(self): - ct = UserAuthType.from_string("file") - self.assertEqual(ct, UserAuthType.FILE) - - def test_radius_connect(self): - ct = UserAuthType.from_string("radius_connect") - self.assertEqual(ct, UserAuthType.RADIUS_CONNECT) - - def test_ldap_connect(self): - ct = UserAuthType.from_string("ldap_connect") - self.assertEqual(ct, UserAuthType.LDAP_CONNECT) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv208/system/__init__.py b/tests/protocols/gmpv208/system/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/tests/protocols/gmpv208/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv208/system/test_aggregates.py b/tests/protocols/gmpv208/system/test_aggregates.py deleted file mode 100644 index 0387e5367..000000000 --- a/tests/protocols/gmpv208/system/test_aggregates.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .aggregates import GmpGetAggregatesTestMixin - - -class Gmpv208GetAggregatesTestCase(GmpGetAggregatesTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/system/test_authentication.py b/tests/protocols/gmpv208/system/test_authentication.py deleted file mode 100644 index af9b3c79e..000000000 --- a/tests/protocols/gmpv208/system/test_authentication.py +++ /dev/null @@ -1,25 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .authentication import ( - GmpAuthenticateTestMixin, - GmpDescribeAuthTestMixin, - GmpModifyAuthTestMixin, -) - - -class Gmpv208AuthenticateTestCase(GmpAuthenticateTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208ModifyAuthTestCase(GmpModifyAuthTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208DescribeAuthCommandTestCase( - GmpDescribeAuthTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/system/test_feed.py b/tests/protocols/gmpv208/system/test_feed.py deleted file mode 100644 index 56fd9c388..000000000 --- a/tests/protocols/gmpv208/system/test_feed.py +++ /dev/null @@ -1,15 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin - - -class Gmpv208GetFeedTestCase(GmpGetFeedTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208GetFeedsTestCase(GmpGetFeedsTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/system/test_help.py b/tests/protocols/gmpv208/system/test_help.py deleted file mode 100644 index 50405a86a..000000000 --- a/tests/protocols/gmpv208/system/test_help.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .help import GmpHelpTestMixin - - -class Gmpv208HelpTestCase(GmpHelpTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/system/test_system_reports.py b/tests/protocols/gmpv208/system/test_system_reports.py deleted file mode 100644 index 7d855da4a..000000000 --- a/tests/protocols/gmpv208/system/test_system_reports.py +++ /dev/null @@ -1,13 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .system_reports import GmpGetSystemReportsTestMixin - - -class Gmpv208GetSystemReportsTestCase( - GmpGetSystemReportsTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/system/test_trashcan.py b/tests/protocols/gmpv208/system/test_trashcan.py deleted file mode 100644 index 1d3aa4466..000000000 --- a/tests/protocols/gmpv208/system/test_trashcan.py +++ /dev/null @@ -1,17 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .trashcan import GmpEmptyTrashcanTestMixin, GmpRestoreFromTrashcanTestMixin - - -class Gmpv208EmptyTrashcanTestCase(GmpEmptyTrashcanTestMixin, Gmpv208TestCase): - pass - - -class Gmpv208RestoreFromTrashcanTestCase( - GmpRestoreFromTrashcanTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/system/test_user_settings.py b/tests/protocols/gmpv208/system/test_user_settings.py deleted file mode 100644 index 6542e65a4..000000000 --- a/tests/protocols/gmpv208/system/test_user_settings.py +++ /dev/null @@ -1,29 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .user_settings import ( - GmpGetUserSettingsTestMixin, - GmpGetUserSettingTestMixin, - GmpModifyUserSettingTestMixin, -) - - -class Gmpv208GetUserSettingTestCase( - GmpGetUserSettingTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208GetUserSettingsTestCase( - GmpGetUserSettingsTestMixin, Gmpv208TestCase -): - pass - - -class Gmpv208ModifyUserSettingTestCase( - GmpModifyUserSettingTestMixin, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/system/test_versions.py b/tests/protocols/gmpv208/system/test_versions.py deleted file mode 100644 index 4c7216bc0..000000000 --- a/tests/protocols/gmpv208/system/test_versions.py +++ /dev/null @@ -1,17 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208 import Gmpv208TestCase -from .versions import GmpGetProtocolVersionTestCase, GmpGetVersionTestCase - - -class Gmpv208GetVersionCommandTestCase(GmpGetVersionTestCase, Gmpv208TestCase): - pass - - -class Gmpv208GmpGetProtocolVersionTestCase( - GmpGetProtocolVersionTestCase, Gmpv208TestCase -): - pass diff --git a/tests/protocols/gmpv208/system/versions/__init__.py b/tests/protocols/gmpv208/system/versions/__init__.py deleted file mode 100644 index 040a71783..000000000 --- a/tests/protocols/gmpv208/system/versions/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_get_protocol_version import GmpGetProtocolVersionTestCase -from .test_get_version import GmpGetVersionTestCase - -__all__ = ("GmpGetProtocolVersionTestCase", "GmpGetVersionTestCase") diff --git a/tests/protocols/gmpv208/system/versions/test_get_protocol_version.py b/tests/protocols/gmpv208/system/versions/test_get_protocol_version.py deleted file mode 100644 index 3a5c3175e..000000000 --- a/tests/protocols/gmpv208/system/versions/test_get_protocol_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -class GmpGetProtocolVersionTestCase: - def test_protocol_version(self): - self.assertEqual(self.gmp.get_protocol_version(), (20, 8)) diff --git a/tests/protocols/gmpv208/test_gmp_types.py b/tests/protocols/gmpv208/test_gmp_types.py deleted file mode 100644 index 81086c1cc..000000000 --- a/tests/protocols/gmpv208/test_gmp_types.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering - -from . import Gmpv208TestCase - - -class GmpWithStatementTestMixin: - def test_types(self): - with self.gmp: - # Test that the values are equal - self.assertEqual( - self.gmp.types.AlertEvent.TASK_RUN_STATUS_CHANGED.value, - "Task run status changed", - ) - self.assertEqual( - self.gmp.types.PermissionSubjectType.USER.value, "user" - ) - self.assertEqual( - self.gmp.types.HostsOrdering.RANDOM.value, "random" - ) - - # Test usability of from_string - self.assertEqual( - self.gmp.types.HostsOrdering.from_string("reverse"), - self.gmp.types.HostsOrdering.REVERSE, - ) - - # Test, that the Enum class types are equal - self.assertEqual(self.gmp.types.HostsOrdering, HostsOrdering) - - -class Gmpv208WithStatementTestCase(GmpWithStatementTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv208/test_with_statement.py b/tests/protocols/gmpv208/test_with_statement.py deleted file mode 100644 index cfd90e790..000000000 --- a/tests/protocols/gmpv208/test_with_statement.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from . import Gmpv208TestCase - - -class GmpWithStatementTestMixin: - def test_with_statement(self): - self.connection.connect.has_not_been_called() - self.connection.disconnect.has_not_been_called() - - with self.gmp: - pass - - self.connection.connect.has_been_called() - self.connection.disconnect.has_been_called() - - -class Gmpv208WithStatementTestCase(GmpWithStatementTestMixin, Gmpv208TestCase): - pass diff --git a/tests/protocols/gmpv214/__init__.py b/tests/protocols/gmpv214/__init__.py deleted file mode 100644 index 894cd0b9c..000000000 --- a/tests/protocols/gmpv214/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -from gvm.protocols.gmpv214 import Gmp - -from .. import GmpTestCase - - -class Gmpv214TestCase(GmpTestCase): - gmp_class = Gmp diff --git a/tests/protocols/gmpv214/entities/__init__.py b/tests/protocols/gmpv214/entities/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/tests/protocols/gmpv214/entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv214/entities/notes/__init__.py b/tests/protocols/gmpv214/entities/notes/__init__.py deleted file mode 100644 index 5ade3a35f..000000000 --- a/tests/protocols/gmpv214/entities/notes/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_create_note import GmpCreateNoteTestMixin -from .test_modify_note import GmpModifyNoteTestMixin - -__all__ = ("GmpCreateNoteTestMixin", "GmpModifyNoteTestMixin") diff --git a/tests/protocols/gmpv214/entities/notes/test_create_note.py b/tests/protocols/gmpv214/entities/notes/test_create_note.py deleted file mode 100644 index 6baa7c31d..000000000 --- a/tests/protocols/gmpv214/entities/notes/test_create_note.py +++ /dev/null @@ -1,167 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv214 import SeverityLevel - - -class GmpCreateNoteTestMixin: - def test_create_note(self): - self.gmp.create_note("foo", nvt_oid="oid1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_note_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_note(None, "od1") - - with self.assertRaises(RequiredArgument): - self.gmp.create_note("", "oid1") - - def test_create_note_missing_nvt_oid(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_note("foo", None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_note("foo", "") - - def test_create_note_with_hosts(self): - self.gmp.create_note("foo", nvt_oid="oid1", hosts=[]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", hosts=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" - ) - - def test_create_note_with_port(self): - self.gmp.create_note("foo", nvt_oid="oid1", port="666/tcp") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "666/tcp" - "" - ) - - def test_create_note_with_result_id(self): - self.gmp.create_note("foo", nvt_oid="oid1", result_id="r1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_note_with_task_id(self): - self.gmp.create_note("foo", nvt_oid="oid1", task_id="t1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_note_with_severity(self): - self.gmp.create_note("foo", nvt_oid="oid1", severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_note_with_threat(self): - self.gmp.create_note("foo", nvt_oid="oid1", threat=SeverityLevel.HIGH) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_note_with_days_active(self): - self.gmp.create_note("foo", nvt_oid="oid1", days_active=0) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", days_active=-1) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" - ) - - self.gmp.create_note("foo", nvt_oid="oid1", days_active=3600) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" - ) - - def test_create_note_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.create_note(text="foo", nvt_oid="oid1", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.create_note(text="foo", nvt_oid="oid1", port="tcp/123") diff --git a/tests/protocols/gmpv214/entities/notes/test_modify_note.py b/tests/protocols/gmpv214/entities/notes/test_modify_note.py deleted file mode 100644 index 1284a3fd2..000000000 --- a/tests/protocols/gmpv214/entities/notes/test_modify_note.py +++ /dev/null @@ -1,159 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv214 import SeverityLevel - - -class GmpModifyNoteTestMixin: - def test_modify_note(self): - self.gmp.modify_note(note_id="n1", text="foo") - - self.connection.send.has_been_called_with( - 'foo' - ) - - def test_modify_note_missing_note_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id=None, text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="", text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note("", text="foo") - - def test_modify_note_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="n1", text="") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note(note_id="n1", text=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_note("n1", "") - - def test_modify_note_with_days_active(self): - self.gmp.modify_note(note_id="n1", text="foo", days_active=0) - - self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", days_active=-1) - - self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", days_active=600) - - self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" - ) - - def test_modify_note_with_port(self): - self.gmp.modify_note(note_id="n1", text="foo", port="123/tcp") - - self.connection.send.has_been_called_with( - '' - "foo" - "123/tcp" - "" - ) - - def test_modify_note_with_hosts(self): - self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" - ) - - def test_modify_note_with_result_id(self): - self.gmp.modify_note(note_id="n1", text="foo", result_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_note_with_task_id(self): - self.gmp.modify_note(note_id="n1", text="foo", task_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_note_with_severity(self): - self.gmp.modify_note(note_id="n1", text="foo", severity="5.5") - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_note(note_id="n1", text="foo", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_note_with_threat(self): - self.gmp.modify_note( - note_id="n1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - 'foo' - ) - - def test_modify_note_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.modify_note(note_id="o1", text="foo", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.modify_note(note_id="o1", text="foo", port="tcp/123") diff --git a/tests/protocols/gmpv214/entities/overrides/__init__.py b/tests/protocols/gmpv214/entities/overrides/__init__.py deleted file mode 100644 index 9784893cf..000000000 --- a/tests/protocols/gmpv214/entities/overrides/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_create_override import GmpCreateOverrideTestMixin -from .test_modify_override import GmpModifyOverrideTestMixin - -__all__ = ("GmpCreateOverrideTestMixin", "GmpModifyOverrideTestMixin") diff --git a/tests/protocols/gmpv214/entities/overrides/test_create_override.py b/tests/protocols/gmpv214/entities/overrides/test_create_override.py deleted file mode 100644 index 387249462..000000000 --- a/tests/protocols/gmpv214/entities/overrides/test_create_override.py +++ /dev/null @@ -1,214 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv214 import SeverityLevel - - -class GmpCreateOverrideTestMixin: - def test_create_override(self): - self.gmp.create_override("foo", nvt_oid="oid1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_override_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_override(None, "od1") - - with self.assertRaises(RequiredArgument): - self.gmp.create_override("", "oid1") - - def test_create_override_missing_nvt_oid(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_override("foo", None) - - with self.assertRaises(RequiredArgument): - self.gmp.create_override("foo", "") - - def test_create_override_with_hosts(self): - self.gmp.create_override("foo", nvt_oid="oid1", hosts=[]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", hosts=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" - ) - - def test_create_override_with_port(self): - self.gmp.create_override(nvt_oid="oid1", text="foo", port="123/udp") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "123/udp" - "" - ) - - def test_create_override_with_result_id(self): - self.gmp.create_override("foo", nvt_oid="oid1", result_id="r1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_override_with_task_id(self): - self.gmp.create_override("foo", nvt_oid="oid1", task_id="t1") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" - ) - - def test_create_override_with_severity(self): - self.gmp.create_override("foo", nvt_oid="oid1", severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", severity=Decimal(5.5)) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_override_with_new_severity(self): - self.gmp.create_override("foo", nvt_oid="oid1", new_severity="5.5") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", new_severity=5.5) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - self.gmp.create_override( - "foo", nvt_oid="oid1", new_severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_override_with_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_override_with_new_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_override_with_days_active(self): - self.gmp.create_override("foo", nvt_oid="oid1", days_active=0) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", days_active=-1) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" - ) - - self.gmp.create_override("foo", nvt_oid="oid1", days_active=3600) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" - ) - - def test_create_override_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.create_override(nvt_oid="oid1", text="foo", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.create_override(nvt_oid="oid1", text="foo", port="tcp/123") diff --git a/tests/protocols/gmpv214/entities/overrides/test_modify_override.py b/tests/protocols/gmpv214/entities/overrides/test_modify_override.py deleted file mode 100644 index ba6cb6b24..000000000 --- a/tests/protocols/gmpv214/entities/overrides/test_modify_override.py +++ /dev/null @@ -1,212 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from decimal import Decimal - -from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv214 import SeverityLevel - - -class GmpModifyOverrideTestMixin: - def test_modify_override(self): - self.gmp.modify_override(override_id="o1", text="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_override_missing_override_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id=None, text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="", text="foo") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override("", text="foo") - - def test_modify_override_missing_text(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="o1", text="") - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override(override_id="o1", text=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_override("o1", "") - - def test_modify_override_with_days_active(self): - self.gmp.modify_override(override_id="o1", text="foo", days_active=0) - - self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", days_active=-1) - - self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", days_active=600) - - self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" - ) - - def test_modify_override_with_port(self): - self.gmp.modify_override(override_id="o1", text="foo", port="123/udp") - - self.connection.send.has_been_called_with( - '' - "foo" - "123/udp" - "" - ) - - def test_modify_override_with_hosts(self): - self.gmp.modify_override(override_id="o1", text="foo", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", hosts=["foo", "bar"] - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" - ) - - def test_modify_override_with_result_id(self): - self.gmp.modify_override(override_id="o1", text="foo", result_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_override_with_task_id(self): - self.gmp.modify_override(override_id="o1", text="foo", task_id="r1") - - self.connection.send.has_been_called_with( - '' - "foo" - '' - "" - ) - - def test_modify_override_with_severity(self): - self.gmp.modify_override(override_id="o1", text="foo", severity="5.5") - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_override_with_new_severity(self): - self.gmp.modify_override( - override_id="o1", text="foo", new_severity="5.5" - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override(override_id="o1", text="foo", new_severity=5.5) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - self.gmp.modify_override( - override_id="o1", text="foo", new_severity=Decimal(5.5) - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_override_with_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_override_with_new_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_override_with_invalid_port(self): - with self.assertRaises(InvalidArgument): - self.gmp.modify_override(override_id="o1", text="foo", port="123") - - with self.assertRaises(InvalidArgument): - self.gmp.modify_override( - override_id="o1", text="foo", port="tcp/123" - ) diff --git a/tests/protocols/gmpv214/entities/scanners/__init__.py b/tests/protocols/gmpv214/entities/scanners/__init__.py deleted file mode 100644 index be250ae97..000000000 --- a/tests/protocols/gmpv214/entities/scanners/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_create_scanner import GmpCreateScannerTestMixin -from .test_modify_scanner import GmpModifyScannerTestMixin - -__all__ = ("GmpCreateScannerTestMixin", "GmpModifyScannerTestMixin") diff --git a/tests/protocols/gmpv214/entities/scanners/test_create_scanner.py b/tests/protocols/gmpv214/entities/scanners/test_create_scanner.py deleted file mode 100644 index af0ebdb22..000000000 --- a/tests/protocols/gmpv214/entities/scanners/test_create_scanner.py +++ /dev/null @@ -1,193 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv214 import ScannerType - - -class GmpCreateScannerTestMixin: - def test_create_scanner(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - '' - "" - ) - - def test_create_scanner_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name=None, - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="", - host="localhost", - port=1234, - scanner_type="1", - credential_id="c1", - ) - - def test_create_scanner_missing_host(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host=None, - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - def test_create_scanner_missing_port(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=None, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port="", - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - def test_create_scanner_missing_scanner_type(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=None, - credential_id="c1", - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="", - credential_id="c1", - ) - - def test_create_scanner_missing_credential_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id=None, - ) - - with self.assertRaises(RequiredArgument): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="", - ) - - def test_create_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="bar", - credential_id="c1", - ) - - with self.assertRaises(AttributeError): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.GMP_SCANNER_TYPE, # pylint: disable=no-member - credential_id="c1", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type="55", - credential_id="c1", - ) - - def test_create_scanner_with_ca_pub(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - ca_pub="foo", - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - "foo" - '' - "" - ) - - def test_create_scanner_with_comment(self): - self.gmp.create_scanner( - name="foo", - host="localhost", - port=1234, - scanner_type=ScannerType.OSP_SCANNER_TYPE, - credential_id="c1", - comment="bar", - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "1" - '' - "bar" - "" - ) diff --git a/tests/protocols/gmpv214/entities/scanners/test_modify_scanner.py b/tests/protocols/gmpv214/entities/scanners/test_modify_scanner.py deleted file mode 100644 index 4dd8a5245..000000000 --- a/tests/protocols/gmpv214/entities/scanners/test_modify_scanner.py +++ /dev/null @@ -1,137 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv214 import ScannerType - - -class GmpModifyScannerTestMixin: - def test_modify_scanner(self): - self.gmp.modify_scanner(scanner_id="s1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_modify_scanner_missing_scanner_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_scanner(scanner_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_scanner(scanner_id="") - - def test_modify_scanner_with_comment(self): - self.gmp.modify_scanner(scanner_id="s1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_host(self): - self.gmp.modify_scanner(scanner_id="s1", host="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_port(self): - self.gmp.modify_scanner(scanner_id="s1", port=1234) - - self.connection.send.has_been_called_with( - '' - "1234" - "" - ) - - self.gmp.modify_scanner(scanner_id="s1", port="1234") - - self.connection.send.has_been_called_with( - '' - "1234" - "" - ) - - def test_modify_scanner_with_name(self): - self.gmp.modify_scanner(scanner_id="s1", name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_ca_pub(self): - self.gmp.modify_scanner(scanner_id="s1", ca_pub="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_scanner_with_credential_id(self): - self.gmp.modify_scanner(scanner_id="s1", credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_scanner_with_scanner_type(self): - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.OSP_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.OPENVAS_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "2" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", scanner_type=ScannerType.CVE_SCANNER_TYPE - ) - - self.connection.send.has_been_called_with( - '' - "3" - "" - ) - - self.gmp.modify_scanner( - scanner_id="s1", - scanner_type=ScannerType.GREENBONE_SENSOR_SCANNER_TYPE, - ) - - self.connection.send.has_been_called_with( - '' - "5" - "" - ) - - def test_modify_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type="-1") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_scanner(scanner_id="s1", scanner_type=1) diff --git a/tests/protocols/gmpv214/entities/targets/__init__.py b/tests/protocols/gmpv214/entities/targets/__init__.py deleted file mode 100644 index 46d7dceb7..000000000 --- a/tests/protocols/gmpv214/entities/targets/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_create_target import GmpCreateTargetTestMixin -from .test_modify_target import GmpModifyTargetTestMixin - -__all__ = ("GmpCreateTargetTestMixin", "GmpModifyTargetTestMixin") diff --git a/tests/protocols/gmpv214/entities/targets/test_create_target.py b/tests/protocols/gmpv214/entities/targets/test_create_target.py deleted file mode 100644 index 1c29ba347..000000000 --- a/tests/protocols/gmpv214/entities/targets/test_create_target.py +++ /dev/null @@ -1,225 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv214.entities.targets import AliveTest - - -class GmpCreateTargetTestMixin: - def test_create_target_missing_name(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_target(None, hosts=["foo"]) - - with self.assertRaises(RequiredArgument): - self.gmp.create_target(name=None, hosts=["foo"]) - - with self.assertRaises(RequiredArgument): - self.gmp.create_target("", hosts=["foo"]) - - def test_create_target_with_asset_hosts_filter(self): - self.gmp.create_target("foo", asset_hosts_filter="name=foo") - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_target_missing_hosts(self): - with self.assertRaises(RequiredArgument): - self.gmp.create_target(name="foo") - - def test_create_target_with_comment(self): - self.gmp.create_target("foo", hosts=["foo"], comment="bar") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - "" - ) - - def test_create_target_with_exclude_hosts(self): - self.gmp.create_target( - "foo", hosts=["foo", "bar"], exclude_hosts=["bar", "ipsum"] - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo,bar" - "bar,ipsum" - "" - ) - - def test_create_target_with_ssh_credential(self): - self.gmp.create_target("foo", hosts=["foo"], ssh_credential_id="c1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) - - def test_create_target_with_ssh_credential_port(self): - self.gmp.create_target( - "foo", - hosts=["foo"], - ssh_credential_id="c1", - ssh_credential_port=123, - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "123" - "" - "" - ) - - def test_create_target_with_smb_credential_id(self): - self.gmp.create_target("foo", hosts=["foo"], smb_credential_id="c1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) - - def test_create_target_with_esxi_credential_id(self): - self.gmp.create_target("foo", hosts=["foo"], esxi_credential_id="c1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) - - def test_create_target_with_snmp_credential_id(self): - self.gmp.create_target("foo", hosts=["foo"], snmp_credential_id="c1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) - - def test_create_target_with_alive_tests(self): - self.gmp.create_target( - "foo", hosts=["foo"], alive_test=AliveTest.ICMP_PING - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "ICMP Ping" - "" - ) - - def test_create_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_target("foo", hosts=["foo"], alive_test="foo") - - def test_create_target_with_allow_simultaneous_ips(self): - self.gmp.create_target( - "foo", hosts=["foo"], allow_simultaneous_ips=True - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" - ) - - self.gmp.create_target( - "foo", hosts=["foo"], allow_simultaneous_ips=False - ) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" - ) - - def test_create_target_with_reverse_lookup_only(self): - self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_only=True) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" - ) - - self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_only=False) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" - ) - - def test_create_target_with_reverse_lookup_unify(self): - self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_unify=True) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" - ) - - self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_unify=False) - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" - ) - - def test_create_target_with_port_range(self): - self.gmp.create_target("foo", hosts=["foo"], port_range="bar") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - "" - ) - - def test_create_target_with_port_list_id(self): - self.gmp.create_target("foo", hosts=["foo"], port_list_id="pl1") - - self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" - ) diff --git a/tests/protocols/gmpv214/entities/targets/test_modify_target.py b/tests/protocols/gmpv214/entities/targets/test_modify_target.py deleted file mode 100644 index 4ab53e914..000000000 --- a/tests/protocols/gmpv214/entities/targets/test_modify_target.py +++ /dev/null @@ -1,211 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv214.entities.targets import AliveTest - - -class GmpModifyTargetTestMixin: - def test_modify_target(self): - self.gmp.modify_target(target_id="t1") - - self.connection.send.has_been_called_with( - '' - ) - - def test_modify_target_missing_target_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_target(target_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_target(target_id="") - - def test_modify_target_with_comment(self): - self.gmp.modify_target(target_id="t1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_target_with_hosts(self): - self.gmp.modify_target(target_id="t1", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - "" - ) - - self.gmp.modify_target(target_id="t1", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "" - "" - ) - - def test_modify_target_with_hosts_and_exclude_hosts(self): - self.gmp.modify_target( - target_id="t1", hosts=["foo", "bar"], exclude_hosts=["foo"] - ) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "foo" - "" - ) - - def test_modify_target_with_name(self): - self.gmp.modify_target(target_id="t1", name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_target_with_exclude_hosts(self): - self.gmp.modify_target(target_id="t1", exclude_hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - self.gmp.modify_target(target_id="t1", exclude_hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - "foo,bar" - "" - ) - - def test_modify_target_with_ssh_credential(self): - self.gmp.modify_target(target_id="t1", ssh_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_ssh_credential_port(self): - self.gmp.modify_target( - target_id="t1", ssh_credential_id="c1", ssh_credential_port=123 - ) - - self.connection.send.has_been_called_with( - '' - '' - "123" - "" - "" - ) - - def test_modify_target_with_smb_credential_id(self): - self.gmp.modify_target(target_id="t1", smb_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_esxi_credential_id(self): - self.gmp.modify_target(target_id="t1", esxi_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_snmp_credential_id(self): - self.gmp.modify_target(target_id="t1", snmp_credential_id="c1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - def test_modify_target_with_alive_tests(self): - self.gmp.modify_target(target_id="t1", alive_test=AliveTest.ICMP_PING) - - self.connection.send.has_been_called_with( - '' - "ICMP Ping" - "" - ) - - def test_modify_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_target(target_id="t1", alive_test="foo") - - def test_modify_target_with_allow_simultaneous_ips(self): - self.gmp.modify_target(target_id="t1", allow_simultaneous_ips=True) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_target(target_id="t1", allow_simultaneous_ips=False) - - self.connection.send.has_been_called_with( - '' - "0" - "" - ) - - def test_modify_target_with_reverse_lookup_only(self): - self.gmp.modify_target(target_id="t1", reverse_lookup_only=True) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_target(target_id="t1", reverse_lookup_only=False) - - self.connection.send.has_been_called_with( - '' - "0" - "" - ) - - def test_modify_target_with_reverse_lookup_unify(self): - self.gmp.modify_target(target_id="t1", reverse_lookup_unify=True) - - self.connection.send.has_been_called_with( - '' - "1" - "" - ) - - self.gmp.modify_target(target_id="t1", reverse_lookup_unify=False) - - self.connection.send.has_been_called_with( - '' - "0" - "" - ) - - def test_modify_target_with_port_list_id(self): - self.gmp.modify_target(target_id="t1", port_list_id="pl1") - - self.connection.send.has_been_called_with( - '' - '' - "" - ) diff --git a/tests/protocols/gmpv214/entities/test_alerts.py b/tests/protocols/gmpv214/entities/test_alerts.py deleted file mode 100644 index 822c4e6d2..000000000 --- a/tests/protocols/gmpv214/entities/test_alerts.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.alerts import ( - GmpCloneAlertTestMixin, - GmpCreateAlertTestMixin, - GmpDeleteAlertTestMixin, - GmpGetAlertsTestMixin, - GmpGetAlertTestMixin, - GmpModifyAlertTestMixin, - GmpTestAlertTestMixin, - GmpTriggerAlertTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneAlertTestCase(GmpCloneAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateAlertTestCase(GmpCreateAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteAlertTestCase(GmpDeleteAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetAlertTestCase(GmpGetAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetAlertsTestCase(GmpGetAlertsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyAlertTestCase(GmpModifyAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214TestAlertTestCase(GmpTestAlertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214TriggerAlertTestCase(GmpTriggerAlertTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_audits.py b/tests/protocols/gmpv214/entities/test_audits.py deleted file mode 100644 index c1832ba4e..000000000 --- a/tests/protocols/gmpv214/entities/test_audits.py +++ /dev/null @@ -1,53 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.audits import ( - GmpCloneAuditTestMixin, - GmpCreateAuditTestMixin, - GmpDeleteAuditTestMixin, - GmpGetAuditsTestMixin, - GmpGetAuditTestMixin, - GmpModifyAuditTestMixin, - GmpResumeAuditTestMixin, - GmpStartAuditTestMixin, - GmpStopAuditTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneAuditTestCase(GmpCloneAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateAuditTestCase(GmpCreateAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteAuditTestCase(GmpDeleteAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetAuditTestCase(GmpGetAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetAuditsTestCase(GmpGetAuditsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyAuditTestCase(GmpModifyAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ResumeAuditTestCase(GmpResumeAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214StartAuditTestCase(GmpStartAuditTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214StopAuditTestCase(GmpStopAuditTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_credentials.py b/tests/protocols/gmpv214/entities/test_credentials.py deleted file mode 100644 index d26b5cfcd..000000000 --- a/tests/protocols/gmpv214/entities/test_credentials.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.credentials import ( - GmpCloneCredentialTestMixin, - GmpCreateCredentialTestMixin, - GmpDeleteCredentialTestMixin, - GmpGetCredentialsTestMixin, - GmpGetCredentialTestMixin, - GmpModifyCredentialTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneCredentialTestCase( - GmpCloneCredentialTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreateCredentialTestCase( - GmpCreateCredentialTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeleteCredentialTestCase( - GmpDeleteCredentialTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetCredentialTestCase(GmpGetCredentialTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetCredentialsTestCase( - GmpGetCredentialsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyCredentialTestCase( - GmpModifyCredentialTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_filters.py b/tests/protocols/gmpv214/entities/test_filters.py deleted file mode 100644 index 9a47044ae..000000000 --- a/tests/protocols/gmpv214/entities/test_filters.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.filters import ( - GmpCloneFilterTestMixin, - GmpCreateFilterTestMixin, - GmpDeleteFilterTestMixin, - GmpGetFiltersTestMixin, - GmpGetFilterTestMixin, - GmpModifyFilterTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteFilterTestCase(GmpDeleteFilterTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetFilterTestCase(GmpGetFilterTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetFiltersTestCase(GmpGetFiltersTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneFilterTestCase(GmpCloneFilterTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateFilterTestCase(GmpCreateFilterTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyFilterTestCase(GmpModifyFilterTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_groups.py b/tests/protocols/gmpv214/entities/test_groups.py deleted file mode 100644 index d0737590b..000000000 --- a/tests/protocols/gmpv214/entities/test_groups.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.groups import ( - GmpCloneGroupTestMixin, - GmpCreateGroupTestMixin, - GmpDeleteGroupTestMixin, - GmpGetGroupsTestMixin, - GmpGetGroupTestMixin, - GmpModifyGroupTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteGroupTestCase(GmpDeleteGroupTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetGroupTestCase(GmpGetGroupTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetGroupsTestCase(GmpGetGroupsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneGroupTestCase(GmpCloneGroupTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateGroupTestCase(GmpCreateGroupTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyGroupTestCase(GmpModifyGroupTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_hosts.py b/tests/protocols/gmpv214/entities/test_hosts.py deleted file mode 100644 index e5ca14fdc..000000000 --- a/tests/protocols/gmpv214/entities/test_hosts.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.hosts import ( - GmpCreateHostTestMixin, - GmpDeleteHostTestMixin, - GmpGetHostsTestMixin, - GmpGetHostTestMixin, - GmpModifyHostTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CreateHostTestCase(GmpCreateHostTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteHostTestCase(GmpDeleteHostTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetHostTestCase(GmpGetHostTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetHostsTestCase(GmpGetHostsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyHostTestCase(GmpModifyHostTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_notes.py b/tests/protocols/gmpv214/entities/test_notes.py deleted file mode 100644 index 962db7b23..000000000 --- a/tests/protocols/gmpv214/entities/test_notes.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.notes import ( - GmpCloneNoteTestMixin, - GmpDeleteNoteTestMixin, - GmpGetNotesTestMixin, - GmpGetNoteTestMixin, -) -from ...gmpv214 import Gmpv214TestCase -from .notes import GmpCreateNoteTestMixin, GmpModifyNoteTestMixin - - -class Gmpv214DeleteNoteTestCase(GmpDeleteNoteTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetNoteTestCase(GmpGetNoteTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetNotesTestCase(GmpGetNotesTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneNoteTestCase(GmpCloneNoteTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateNoteTestCase(GmpCreateNoteTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyNoteTestCase(GmpModifyNoteTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_operating_systems.py b/tests/protocols/gmpv214/entities/test_operating_systems.py deleted file mode 100644 index 10c74355f..000000000 --- a/tests/protocols/gmpv214/entities/test_operating_systems.py +++ /dev/null @@ -1,36 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.operating_systems import ( - GmpDeleteOperatingSystemTestMixin, - GmpGetOperatingSystemsTestMixin, - GmpGetOperatingSystemTestMixin, - GmpModifyOperatingSystemTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteOperatingSystemTestCase( - GmpDeleteOperatingSystemTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetOperatingSystemTestCase( - GmpGetOperatingSystemTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetOperatingSystemsTestCase( - GmpGetOperatingSystemsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyOperatingSystemTestCase( - GmpModifyOperatingSystemTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_overrides.py b/tests/protocols/gmpv214/entities/test_overrides.py deleted file mode 100644 index f75a78d32..000000000 --- a/tests/protocols/gmpv214/entities/test_overrides.py +++ /dev/null @@ -1,43 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.overrides import ( - GmpCloneOverrideTestMixin, - GmpDeleteOverrideTestMixin, - GmpGetOverridesTestMixin, - GmpGetOverrideTestMixin, -) -from ...gmpv214 import Gmpv214TestCase -from .overrides import GmpCreateOverrideTestMixin, GmpModifyOverrideTestMixin - - -class Gmpv214CloneOverrideTestCase(GmpCloneOverrideTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateOverrideTestCase( - GmpCreateOverrideTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeleteOverrideTestCase( - GmpDeleteOverrideTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetOverrideTestCase(GmpGetOverrideTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetOverridesTestCase(GmpGetOverridesTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyOverrideTestCase( - GmpModifyOverrideTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_permissions.py b/tests/protocols/gmpv214/entities/test_permissions.py deleted file mode 100644 index 921879a90..000000000 --- a/tests/protocols/gmpv214/entities/test_permissions.py +++ /dev/null @@ -1,48 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.permissions import ( - GmpClonePermissionTestMixin, - GmpCreatePermissionTestMixin, - GmpDeletePermissionTestMixin, - GmpGetPermissionsTestMixin, - GmpGetPermissionTestMixin, - GmpModifyPermissionTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeletePermissionTestCase( - GmpDeletePermissionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetPermissionTestCase(GmpGetPermissionTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetPermissionsTestCase( - GmpGetPermissionsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ClonePermissionTestCase( - GmpClonePermissionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreatePermissionTestCase( - GmpCreatePermissionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPermissionTestCase( - GmpModifyPermissionTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_policies.py b/tests/protocols/gmpv214/entities/test_policies.py deleted file mode 100644 index ed87cbde4..000000000 --- a/tests/protocols/gmpv214/entities/test_policies.py +++ /dev/null @@ -1,80 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.policies import ( - GmpClonePolicyTestMixin, - GmpCreatePolicyTestMixin, - GmpDeletePolicyTestMixin, - GmpGetPoliciesTestMixin, - GmpGetPolicyTestMixin, - GmpImportPolicyTestMixin, - GmpModifyPolicySetCommentTestMixin, - GmpModifyPolicySetFamilySelectionTestMixin, - GmpModifyPolicySetNameTestMixin, - GmpModifyPolicySetNvtPreferenceTestMixin, - GmpModifyPolicySetNvtSelectionTestMixin, - GmpModifyPolicySetScannerPreferenceTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214ClonePolicyTestCase(GmpClonePolicyTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreatePolicyTestCase(GmpCreatePolicyTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeletePolicyTestCase(GmpDeletePolicyTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetPolicyTestCase(GmpGetPolicyTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetPoliciesTestCase(GmpGetPoliciesTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ImportPolicyTestCase(GmpImportPolicyTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyPolicySetCommentTestCase( - GmpModifyPolicySetCommentTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPolicySetFamilySelectionTestCase( - GmpModifyPolicySetFamilySelectionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPolicySetNvtSelectionTestCase( - GmpModifyPolicySetNvtSelectionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPolicySetNameTestCase( - GmpModifyPolicySetNameTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPolicySetNvtPreferenceTestCase( - GmpModifyPolicySetNvtPreferenceTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyPolicySetScannerPreferenceTestCase( - GmpModifyPolicySetScannerPreferenceTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_port_lists.py b/tests/protocols/gmpv214/entities/test_port_lists.py deleted file mode 100644 index 8d129c133..000000000 --- a/tests/protocols/gmpv214/entities/test_port_lists.py +++ /dev/null @@ -1,58 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.port_lists import ( - GmpClonePortListTestMixin, - GmpCreatePortListTestMixin, - GmpCreatePortRangeTestMixin, - GmpDeletePortListTestMixin, - GmpDeletePortRangeTestMixin, - GmpGetPortListsTestMixin, - GmpGetPortListTestMixin, - GmpModifyPortListTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214ClonePortListTestCase(GmpClonePortListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreatePortListTestCase( - GmpCreatePortListTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreatePortRangeListTestCase( - GmpCreatePortRangeTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeletePortListTestCase( - GmpDeletePortListTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeletePortRangeTestCase( - GmpDeletePortRangeTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetPortListTestCase(GmpGetPortListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetPortListsTestCase(GmpGetPortListsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyPortListTestCase( - GmpModifyPortListTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_report_formats.py b/tests/protocols/gmpv214/entities/test_report_formats.py deleted file mode 100644 index 2ac69ccc1..000000000 --- a/tests/protocols/gmpv214/entities/test_report_formats.py +++ /dev/null @@ -1,57 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.report_formats import ( - GmpCloneReportFormatTestMixin, - GmpDeleteReportFormatTestMixin, - GmpGetReportFormatsTestMixin, - GmpGetReportFormatTestMixin, - GmpImportReportFormatTestMixin, - GmpModifyReportFormatTestMixin, - GmpVerifyReportFormatTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteReportFormatTestCase( - GmpDeleteReportFormatTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetReportFormatTestCase( - GmpGetReportFormatTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetReportFormatsTestCase( - GmpGetReportFormatsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CloneReportFormatTestCase( - GmpCloneReportFormatTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ImportReportFormatTestCase( - GmpImportReportFormatTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyReportFormatTestCase( - GmpModifyReportFormatTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214VerifyReportFormatTestCase( - GmpVerifyReportFormatTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_reports.py b/tests/protocols/gmpv214/entities/test_reports.py deleted file mode 100644 index 5d0c97bed..000000000 --- a/tests/protocols/gmpv214/entities/test_reports.py +++ /dev/null @@ -1,28 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.reports import ( - GmpDeleteReportTestMixin, - GmpGetReportsTestMixin, - GmpGetReportTestMixin, - GmpImportReportTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteReportTestCase(GmpDeleteReportTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetReportTestCase(GmpGetReportTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetReportsTestCase(GmpGetReportsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ImportReportTestCase(GmpImportReportTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_results.py b/tests/protocols/gmpv214/entities/test_results.py deleted file mode 100644 index 679df1c7d..000000000 --- a/tests/protocols/gmpv214/entities/test_results.py +++ /dev/null @@ -1,18 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.results import ( - GmpGetResultsTestMixin, - GmpGetResultTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetResultTestCase(GmpGetResultTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetResultsTestCase(GmpGetResultsTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_roles.py b/tests/protocols/gmpv214/entities/test_roles.py deleted file mode 100644 index dbd6f42ab..000000000 --- a/tests/protocols/gmpv214/entities/test_roles.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.roles import ( - GmpCloneRoleTestMixin, - GmpCreateRoleTestMixin, - GmpDeleteRoleTestMixin, - GmpGetRolesTestMixin, - GmpGetRoleTestMixin, - GmpModifyRoleTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteRoleTestCase(GmpDeleteRoleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetRoleTestCase(GmpGetRoleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetRolesTestCase(GmpGetRolesTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneRoleTestCase(GmpCloneRoleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateRoleTestCase(GmpCreateRoleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyRoleTestCase(GmpModifyRoleTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_scan_configs.py b/tests/protocols/gmpv214/entities/test_scan_configs.py deleted file mode 100644 index f6f46e2b9..000000000 --- a/tests/protocols/gmpv214/entities/test_scan_configs.py +++ /dev/null @@ -1,111 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.scan_configs import ( - GmpCloneScanConfigTestMixin, - GmpCreateScanConfigFromOSPScannerTestMixin, - GmpCreateScanConfigTestMixin, - GmpDeleteScanConfigTestMixin, - GmpGetScanConfigsTestMixin, - GmpGetScanConfigTestMixin, - GmpImportScanConfigTestMixin, - GmpModifyScanConfigSetCommentTestMixin, - GmpModifyScanConfigSetFamilySelectionTestMixin, - GmpModifyScanConfigSetNameTestMixin, - GmpModifyScanConfigSetNvtPreferenceTestMixin, - GmpModifyScanConfigSetNvtSelectionTestMixin, - GmpModifyScanConfigSetScannerPreferenceTestMixin, - GmpModifyScanConfigTestMixin, - GmpSyncScanConfigTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneScanConfigTestCase( - GmpCloneScanConfigTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreateScanConfigTestCase( - GmpCreateScanConfigTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreateScanConfigFromOSPScannerTestCase( - GmpCreateScanConfigFromOSPScannerTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeleteScanConfigTestCase( - GmpDeleteScanConfigTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetScanConfigTestCase(GmpGetScanConfigTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetScanConfigsTestCase( - GmpGetScanConfigsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ImportScanConfigTestCase( - GmpImportScanConfigTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetCommentTestCase( - GmpModifyScanConfigSetCommentTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetFamilySelectionTestCase( - GmpModifyScanConfigSetFamilySelectionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetNvtSelectionTestCase( - GmpModifyScanConfigSetNvtSelectionTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetNameTestCase( - GmpModifyScanConfigSetNameTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetNvtPreferenceTestCase( - GmpModifyScanConfigSetNvtPreferenceTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigSetScannerPreferenceTestCase( - GmpModifyScanConfigSetScannerPreferenceTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScanConfigTestCase( - GmpModifyScanConfigTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214SyncScanConfigTestCase( - GmpSyncScanConfigTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_scanners.py b/tests/protocols/gmpv214/entities/test_scanners.py deleted file mode 100644 index baeb45b6d..000000000 --- a/tests/protocols/gmpv214/entities/test_scanners.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.scanners import ( - GmpCloneScannerTestMixin, - GmpDeleteScannerTestMixin, - GmpGetScannersTestMixin, - GmpGetScannerTestMixin, -) -from ...gmpv214 import Gmpv214TestCase -from .scanners import GmpCreateScannerTestMixin, GmpModifyScannerTestMixin - - -class Gmpv214DeleteScannerTestCase(GmpDeleteScannerTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetScannerTestCase(GmpGetScannerTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetScannersTestCase(GmpGetScannersTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneScannerTestCase(GmpCloneScannerTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateScannerTestCase(GmpCreateScannerTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyScannerTestCase(GmpModifyScannerTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_schedules.py b/tests/protocols/gmpv214/entities/test_schedules.py deleted file mode 100644 index 0547aee00..000000000 --- a/tests/protocols/gmpv214/entities/test_schedules.py +++ /dev/null @@ -1,44 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.schedules import ( - GmpCloneScheduleTestMixin, - GmpCreateScheduleTestMixin, - GmpDeleteScheduleTestMixin, - GmpGetSchedulesTestMixin, - GmpGetScheduleTestMixin, - GmpModifyScheduleTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteScheduleTestCase( - GmpDeleteScheduleTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetScheduleTestCase(GmpGetScheduleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetSchedulesTestCase(GmpGetSchedulesTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneScheduleTestCase(GmpCloneScheduleTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateScheduleTestCase( - GmpCreateScheduleTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyScheduleTestCase( - GmpModifyScheduleTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_secinfo.py b/tests/protocols/gmpv214/entities/test_secinfo.py deleted file mode 100644 index 9fe6bb2fe..000000000 --- a/tests/protocols/gmpv214/entities/test_secinfo.py +++ /dev/null @@ -1,103 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.secinfo import ( - GmpGetCertBundListTestMixin, - GmpGetCertBundTestMixin, - GmpGetCpeListTestMixin, - GmpGetCpeTestMixin, - GmpGetCveListTestMixin, - GmpGetCveTestMixin, - GmpGetDfnCertListTestMixin, - GmpGetDfnCertTestMixin, - GmpGetInfoListTestMixin, - GmpGetInfoTestMixin, - GmpGetNvtFamiliesTestMixin, - GmpGetNvtListTestMixin, - GmpGetNvtTestMixin, - GmpGetOvalDefListTestMixin, - GmpGetOvalDefTestMixin, - GmpGetScanConfigNvtsTestMixin, - GmpGetScanConfigNvtTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetCertBundTestCase(GmpGetCertBundTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetCpeTestCase(GmpGetCpeTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetCveTestCase(GmpGetCveTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetDfnCertCase(GmpGetDfnCertTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetOvalDefCase(GmpGetOvalDefTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetInfoListTestCase(GmpGetInfoListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetInfoTestCase(GmpGetInfoTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetNvtTestCase(GmpGetNvtTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetScanConfigNvtTestCase( - GmpGetScanConfigNvtTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetNvtFamiliesTestCase( - GmpGetNvtFamiliesTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetScanConfigNvtsTestCase( - GmpGetScanConfigNvtsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetCertBundListTestCase( - GmpGetCertBundListTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetCpeListTestCase(GmpGetCpeListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetCveListTestCase(GmpGetCveListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetDfnCertListCase(GmpGetDfnCertListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetNvtListTestCase(GmpGetNvtListTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetOvalDefListTestCase( - GmpGetOvalDefListTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_tags.py b/tests/protocols/gmpv214/entities/test_tags.py deleted file mode 100644 index 698761778..000000000 --- a/tests/protocols/gmpv214/entities/test_tags.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.tags import ( - GmpCloneTagTestMixin, - GmpCreateTagTestMixin, - GmpDeleteTagTestMixin, - GmpGetTagsTestMixin, - GmpGetTagTestMixin, - GmpModifyTagTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteTagTestCase(GmpDeleteTagTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTagTestCase(GmpGetTagTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTagsTestCase(GmpGetTagsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneTagTestCase(GmpCloneTagTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateTagTestCase(GmpCreateTagTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyTagTestCase(GmpModifyTagTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_targets.py b/tests/protocols/gmpv214/entities/test_targets.py deleted file mode 100644 index ee00cb8da..000000000 --- a/tests/protocols/gmpv214/entities/test_targets.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.targets import ( - GmpCloneTargetTestMixin, - GmpDeleteTargetTestMixin, - GmpGetTargetsTestMixin, - GmpGetTargetTestMixin, -) -from ...gmpv214 import Gmpv214TestCase -from .targets import GmpCreateTargetTestMixin, GmpModifyTargetTestMixin - - -class Gmpv214CloneTargetTestCase(GmpCloneTargetTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateTargetTestCase(GmpCreateTargetTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteTargetTestCase(GmpDeleteTargetTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTargetTestCase(GmpGetTargetTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTargetsTestCase(GmpGetTargetsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyTargetTestCase(GmpModifyTargetTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_tasks.py b/tests/protocols/gmpv214/entities/test_tasks.py deleted file mode 100644 index 60234ac66..000000000 --- a/tests/protocols/gmpv214/entities/test_tasks.py +++ /dev/null @@ -1,65 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.tasks import ( - GmpCloneTaskTestMixin, - GmpCreateContainerTaskTestMixin, - GmpCreateTaskTestMixin, - GmpDeleteTaskTestMixin, - GmpGetTasksTestMixin, - GmpGetTaskTestMixin, - GmpModifyTaskTestMixin, - GmpMoveTaskTestMixin, - GmpResumeTaskTestMixin, - GmpStartTaskTestMixin, - GmpStopTaskTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneTaskTestCase(GmpCloneTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateContainerTaskTestCase( - GmpCreateContainerTaskTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreateTaskTestCase(GmpCreateTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteTaskTestCase(GmpDeleteTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTaskTestCase(GmpGetTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTasksTestCase(GmpGetTasksTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyTaskTestCase(GmpModifyTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214MoveTaskTestCase(GmpMoveTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ResumeTaskTestCase(GmpResumeTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214StartTaskTestCase(GmpStartTaskTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214StopTaskTestCase(GmpStopTaskTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_tickets.py b/tests/protocols/gmpv214/entities/test_tickets.py deleted file mode 100644 index b98e55379..000000000 --- a/tests/protocols/gmpv214/entities/test_tickets.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.tickets import ( - GmpCloneTicketTestMixin, - GmpCreateTicketTestMixin, - GmpDeleteTicketTestMixin, - GmpGetTicketsTestMixin, - GmpGetTicketTestMixin, - GmpModifyTicketTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214DeleteTicketTestCase(GmpDeleteTicketTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTicketTestCase(GmpGetTicketTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetTicketsTestCase(GmpGetTicketsTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CloneTicketTestCase(GmpCloneTicketTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateTicketTestCase(GmpCreateTicketTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyTicketTestCase(GmpModifyTicketTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_tls_certificates.py b/tests/protocols/gmpv214/entities/test_tls_certificates.py deleted file mode 100644 index 2e7589fa9..000000000 --- a/tests/protocols/gmpv214/entities/test_tls_certificates.py +++ /dev/null @@ -1,50 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.tls_certificates import ( - GmpCloneTLSCertificateTestMixin, - GmpCreateTLSCertificateTestMixin, - GmpDeleteTLSCertificateTestMixin, - GmpGetTLSCertificatesTestMixin, - GmpGetTLSCertificateTestMixin, - GmpModifyTLSCertificateTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214CloneTLSCertificateTestCase( - GmpCloneTLSCertificateTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214CreateTLSCertificateTestCase( - GmpCreateTLSCertificateTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214DeleteTLSCertificateTestCase( - GmpDeleteTLSCertificateTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetTLSCertificateTestCase( - GmpGetTLSCertificateTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetTLSCertificatesTestCase( - GmpGetTLSCertificatesTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyTLSCertificateTestCase( - GmpModifyTLSCertificateTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/test_users.py b/tests/protocols/gmpv214/entities/test_users.py deleted file mode 100644 index 14dc22bb7..000000000 --- a/tests/protocols/gmpv214/entities/test_users.py +++ /dev/null @@ -1,38 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.users import ( - GmpCloneUserTestMixin, - GmpCreateUserTestMixin, - GmpDeleteUserTestMixin, - GmpGetUsersTestMixin, - GmpGetUserTestMixin, -) -from ...gmpv214 import Gmpv214TestCase -from .users import GmpModifyUserTestMixin - - -class Gmpv214CloneUserTestCase(GmpCloneUserTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214CreateUserTestCase(GmpCreateUserTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DeleteUserTestCase(GmpDeleteUserTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetUserTestCase(GmpGetUserTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetUsersTestCase(GmpGetUsersTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyUserTestCase(GmpModifyUserTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/entities/test_vulnerabilities.py b/tests/protocols/gmpv214/entities/test_vulnerabilities.py deleted file mode 100644 index b59d42dc8..000000000 --- a/tests/protocols/gmpv214/entities/test_vulnerabilities.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.entities.vulnerabilities import ( - GmpGetVulnerabilitiesTestMixin, - GmpGetVulnerabilityTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetVulnerabilityTestCase( - GmpGetVulnerabilityTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetVulnerabilitiesTestCase( - GmpGetVulnerabilitiesTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/entities/users/__init__.py b/tests/protocols/gmpv214/entities/users/__init__.py deleted file mode 100644 index a78bae157..000000000 --- a/tests/protocols/gmpv214/entities/users/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_modify_user import GmpModifyUserTestMixin - -__all__ = ("GmpModifyUserTestMixin",) diff --git a/tests/protocols/gmpv214/entities/users/test_modify_user.py b/tests/protocols/gmpv214/entities/users/test_modify_user.py deleted file mode 100644 index 68facf59e..000000000 --- a/tests/protocols/gmpv214/entities/users/test_modify_user.py +++ /dev/null @@ -1,185 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.errors import RequiredArgument -from gvm.protocols.gmpv214 import UserAuthType - - -class GmpModifyUserTestMixin: - def test_modify_user(self): - self.gmp.modify_user(user_id="u1") - - self.connection.send.has_been_called_with('') - - def test_modify_user_missing_user_id(self): - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(user_id=None) - - with self.assertRaises(RequiredArgument): - self.gmp.modify_user(user_id="") - - def test_modify_user_with_new_name(self): - self.gmp.modify_user(user_id="u1", name="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_new_comment(self): - self.gmp.modify_user(user_id="u1", comment="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_role_ids(self): - self.gmp.modify_user(user_id="u1", role_ids=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", role_ids=["r1"]) - - self.connection.send.has_been_called_with( - '' - ) - - self.gmp.modify_user(user_id="u1", role_ids=["r1", "r2"]) - - self.connection.send.has_been_called_with( - '' - '' - '' - "" - ) - - def test_modify_user_with_group_ids(self): - self.gmp.modify_user(user_id="u1", role_ids=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", group_ids=["r1"]) - - self.connection.send.has_been_called_with( - '' - '' - "" - ) - - self.gmp.modify_user(user_id="u1", group_ids=["r1", "r2"]) - - self.connection.send.has_been_called_with( - '' - "" - '' - '' - "" - "" - ) - - def test_modify_user_with_password(self): - self.gmp.modify_user(user_id="u1", password="foo") - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_user_with_auth_source(self): - self.gmp.modify_user( - user_id="u1", auth_source=UserAuthType.LDAP_CONNECT - ) - - self.connection.send.has_been_called_with( - '' - "ldap_connect" - "" - ) - - def test_modify_user_with_hosts(self): - self.gmp.modify_user(user_id="u1", hosts=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", hosts=["foo"]) - - self.connection.send.has_been_called_with( - '' - 'foo' - "" - ) - - self.gmp.modify_user(user_id="u1", hosts=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", hosts=["foo", "bar"], hosts_allow=False - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", hosts=["foo", "bar"], hosts_allow=True - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - def test_modify_user_with_ifaces(self): - self.gmp.modify_user(user_id="u1", ifaces=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u1", ifaces=["foo"]) - - self.connection.send.has_been_called_with( - '' - 'foo' - "" - ) - - self.gmp.modify_user(user_id="u1", ifaces=["foo", "bar"]) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", ifaces=["foo", "bar"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) - - self.gmp.modify_user( - user_id="u1", ifaces=["foo", "bar"], ifaces_allow=True - ) - - self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" - ) diff --git a/tests/protocols/gmpv214/enums/__init__.py b/tests/protocols/gmpv214/enums/__init__.py deleted file mode 100644 index 41d1402cd..000000000 --- a/tests/protocols/gmpv214/enums/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv214/enums/test_aggregate_statistic.py b/tests/protocols/gmpv214/enums/test_aggregate_statistic.py deleted file mode 100644 index d84dc7676..000000000 --- a/tests/protocols/gmpv214/enums/test_aggregate_statistic.py +++ /dev/null @@ -1,61 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AggregateStatistic - - -class GetAggregateStatisticFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AggregateStatistic.from_string("foo") - - def test_none_or_empty(self): - ct = AggregateStatistic.from_string(None) - self.assertIsNone(ct) - ct = AggregateStatistic.from_string("") - self.assertIsNone(ct) - - def test_count(self): - ct = AggregateStatistic.from_string("count") - self.assertEqual(ct, AggregateStatistic.COUNT) - - def test_c_count(self): - ct = AggregateStatistic.from_string("c_count") - self.assertEqual(ct, AggregateStatistic.C_COUNT) - - def test_c_sum(self): - ct = AggregateStatistic.from_string("c_sum") - self.assertEqual(ct, AggregateStatistic.C_SUM) - - def test_max(self): - ct = AggregateStatistic.from_string("max") - self.assertEqual(ct, AggregateStatistic.MAX) - - def test_mean(self): - ct = AggregateStatistic.from_string("mean") - self.assertEqual(ct, AggregateStatistic.MEAN) - - def test_min(self): - ct = AggregateStatistic.from_string("min") - self.assertEqual(ct, AggregateStatistic.MIN) - - def test_sum(self): - ct = AggregateStatistic.from_string("sum") - self.assertEqual(ct, AggregateStatistic.SUM) - - def test_text(self): - ct = AggregateStatistic.from_string("text") - self.assertEqual(ct, AggregateStatistic.TEXT) - - def test_value(self): - ct = AggregateStatistic.from_string("value") - self.assertEqual(ct, AggregateStatistic.VALUE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_alert_condition.py b/tests/protocols/gmpv214/enums/test_alert_condition.py deleted file mode 100644 index 95fd6b9ea..000000000 --- a/tests/protocols/gmpv214/enums/test_alert_condition.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import AlertCondition - - -class GetAlertConditionFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertCondition.from_string("foo") - - def test_none_or_empty(self): - ct = AlertCondition.from_string(None) - self.assertIsNone(ct) - ct = AlertCondition.from_string("") - self.assertIsNone(ct) - - def test_always(self): - ct = AlertCondition.from_string("always") - self.assertEqual(ct, AlertCondition.ALWAYS) - - def test_filter_count_at_least(self): - ct = AlertCondition.from_string("filter count at least") - self.assertEqual(ct, AlertCondition.FILTER_COUNT_AT_LEAST) - - def test_filter_count_changed(self): - ct = AlertCondition.from_string("filter count changed") - self.assertEqual(ct, AlertCondition.FILTER_COUNT_CHANGED) - - def test_severity_at_least(self): - ct = AlertCondition.from_string("severity at least") - self.assertEqual(ct, AlertCondition.SEVERITY_AT_LEAST) - - def test_severity_changed(self): - ct = AlertCondition.from_string("severity changed") - self.assertEqual(ct, AlertCondition.SEVERITY_CHANGED) - - def test_error(self): - ct = AlertCondition.from_string("error") - self.assertEqual(ct, AlertCondition.ERROR) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_alert_event.py b/tests/protocols/gmpv214/enums/test_alert_event.py deleted file mode 100644 index 23d53eed5..000000000 --- a/tests/protocols/gmpv214/enums/test_alert_event.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import AlertEvent - - -class GetAlertEventFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertEvent.from_string("foo") - - def test_none_or_empty(self): - ct = AlertEvent.from_string(None) - self.assertIsNone(ct) - ct = AlertEvent.from_string("") - self.assertIsNone(ct) - - def test_task_run_status_changed(self): - ct = AlertEvent.from_string("Task run status changed") - self.assertEqual(ct, AlertEvent.TASK_RUN_STATUS_CHANGED) - - def test_new_secinfo_arrived(self): - ct = AlertEvent.from_string("New SecInfo arrived") - self.assertEqual(ct, AlertEvent.NEW_SECINFO_ARRIVED) - - def test_updated_secinfo_arrived(self): - ct = AlertEvent.from_string("Updated SecInfo arrived") - self.assertEqual(ct, AlertEvent.UPDATED_SECINFO_ARRIVED) - - def test_ticket_received(self): - ct = AlertEvent.from_string("ticket received") - self.assertEqual(ct, AlertEvent.TICKET_RECEIVED) - - def test_assigned_ticket_changed(self): - ct = AlertEvent.from_string("assigned ticket changed") - self.assertEqual(ct, AlertEvent.ASSIGNED_TICKET_CHANGED) - - def test_owned_ticket_changed(self): - ct = AlertEvent.from_string("owned ticket changed") - self.assertEqual(ct, AlertEvent.OWNED_TICKET_CHANGED) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_alert_method.py b/tests/protocols/gmpv214/enums/test_alert_method.py deleted file mode 100644 index 4a09ab1b2..000000000 --- a/tests/protocols/gmpv214/enums/test_alert_method.py +++ /dev/null @@ -1,73 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import AlertMethod - - -class GetAlertMethodFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AlertMethod.from_string("foo") - - def test_none_or_empty(self): - ct = AlertMethod.from_string(None) - self.assertIsNone(ct) - ct = AlertMethod.from_string("") - self.assertIsNone(ct) - - def test_email(self): - ct = AlertMethod.from_string("email") - self.assertEqual(ct, AlertMethod.EMAIL) - - def test_scp(self): - ct = AlertMethod.from_string("scp") - self.assertEqual(ct, AlertMethod.SCP) - - def test_send(self): - ct = AlertMethod.from_string("send") - self.assertEqual(ct, AlertMethod.SEND) - - def test_smb(self): - ct = AlertMethod.from_string("smb") - self.assertEqual(ct, AlertMethod.SMB) - - def test_snmp(self): - ct = AlertMethod.from_string("snmp") - self.assertEqual(ct, AlertMethod.SNMP) - - def test_syslog(self): - ct = AlertMethod.from_string("syslog") - self.assertEqual(ct, AlertMethod.SYSLOG) - - def test_http_get(self): - ct = AlertMethod.from_string("HTTP Get") - self.assertEqual(ct, AlertMethod.HTTP_GET) - - def test_start_task(self): - ct = AlertMethod.from_string("Start Task") - self.assertEqual(ct, AlertMethod.START_TASK) - - def test_sourcefire_connector(self): - ct = AlertMethod.from_string("sourcefire Connector") - self.assertEqual(ct, AlertMethod.SOURCEFIRE_CONNECTOR) - - def test_verinice_connector(self): - ct = AlertMethod.from_string("verinice Connector") - self.assertEqual(ct, AlertMethod.VERINICE_CONNECTOR) - - def test_tippingpoint_sms(self): - ct = AlertMethod.from_string("Tippingpoint SMS") - self.assertEqual(ct, AlertMethod.TIPPINGPOINT_SMS) - - def test_alemba_vfire(self): - ct = AlertMethod.from_string("Alemba vFire") - self.assertEqual(ct, AlertMethod.ALEMBA_VFIRE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_alive_test.py b/tests/protocols/gmpv214/enums/test_alive_test.py deleted file mode 100644 index 8674b00ad..000000000 --- a/tests/protocols/gmpv214/enums/test_alive_test.py +++ /dev/null @@ -1,65 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import AliveTest - - -class GetAliveTestFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - AliveTest.from_string("foo") - - def test_none_or_empty(self): - ct = AliveTest.from_string(None) - self.assertIsNone(ct) - ct = AliveTest.from_string("") - self.assertIsNone(ct) - - def test_scan_config_default(self): - ct = AliveTest.from_string("Scan Config Default") - self.assertEqual(ct, AliveTest.SCAN_CONFIG_DEFAULT) - - def test_icmp_ping(self): - ct = AliveTest.from_string("ICMP Ping") - self.assertEqual(ct, AliveTest.ICMP_PING) - - def test_tcp_ack_service_ping(self): - ct = AliveTest.from_string("TCP-ACK Service Ping") - self.assertEqual(ct, AliveTest.TCP_ACK_SERVICE_PING) - - def test_tcp_sync_service_ping(self): - ct = AliveTest.from_string("TCP-SYN Service Ping") - self.assertEqual(ct, AliveTest.TCP_SYN_SERVICE_PING) - - def test_arp_ping(self): - ct = AliveTest.from_string("ARP Ping") - self.assertEqual(ct, AliveTest.ARP_PING) - - def test_icmp_and_tcp_ack_service_ping(self): - ct = AliveTest.from_string("ICMP & TCP-ACK Service Ping") - self.assertEqual(ct, AliveTest.ICMP_AND_TCP_ACK_SERVICE_PING) - - def test_icmp_and_arp_ping(self): - ct = AliveTest.from_string("ICMP & ARP Ping") - self.assertEqual(ct, AliveTest.ICMP_AND_ARP_PING) - - def test_tcp_ack_service_and_arp_ping(self): - ct = AliveTest.from_string("TCP-ACK Service & ARP Ping") - self.assertEqual(ct, AliveTest.TCP_ACK_SERVICE_AND_ARP_PING) - - def test_icmp_tcp_ack_service_and_arp_ping(self): - ct = AliveTest.from_string("ICMP, TCP-ACK Service & ARP Ping") - self.assertEqual(ct, AliveTest.ICMP_TCP_ACK_SERVICE_AND_ARP_PING) - - def test_consider_alive(self): - ct = AliveTest.from_string("Consider Alive") - self.assertEqual(ct, AliveTest.CONSIDER_ALIVE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_credential_format.py b/tests/protocols/gmpv214/enums/test_credential_format.py deleted file mode 100644 index aa09c92cc..000000000 --- a/tests/protocols/gmpv214/enums/test_credential_format.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import CredentialFormat - - -class GetCredentialFromatFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - CredentialFormat.from_string("foo") - - def test_none_or_empty(self): - ct = CredentialFormat.from_string(None) - self.assertIsNone(ct) - ct = CredentialFormat.from_string("") - self.assertIsNone(ct) - - def test_key(self): - ct = CredentialFormat.from_string("key") - self.assertEqual(ct, CredentialFormat.KEY) - - def test_rpm(self): - ct = CredentialFormat.from_string("rpm") - self.assertEqual(ct, CredentialFormat.RPM) - - def test_deb(self): - ct = CredentialFormat.from_string("deb") - self.assertEqual(ct, CredentialFormat.DEB) - - def test_exe(self): - ct = CredentialFormat.from_string("exe") - self.assertEqual(ct, CredentialFormat.EXE) - - def test_pem(self): - ct = CredentialFormat.from_string("pem") - self.assertEqual(ct, CredentialFormat.PEM) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_credential_type.py b/tests/protocols/gmpv214/enums/test_credential_type.py deleted file mode 100644 index 51a7358f8..000000000 --- a/tests/protocols/gmpv214/enums/test_credential_type.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import CredentialType - - -class GetCredentialTypeFromStringTestCase(unittest.TestCase): - def test_invalid_type(self): - with self.assertRaises(InvalidArgument): - CredentialType.from_string("foo") - - def test_none_or_empty_type(self): - ct = CredentialType.from_string(None) - self.assertIsNone(ct) - ct = CredentialType.from_string("") - self.assertIsNone(ct) - - def test_client_certificate(self): - ct = CredentialType.from_string("client_certificate") - self.assertEqual(ct, CredentialType.CLIENT_CERTIFICATE) - - def test_snmp(self): - ct = CredentialType.from_string("snmp") - self.assertEqual(ct, CredentialType.SNMP) - - def test_username_password(self): - ct = CredentialType.from_string("username_password") - self.assertEqual(ct, CredentialType.USERNAME_PASSWORD) - - def test_username_ssh_key(self): - ct = CredentialType.from_string("username_ssh_key") - self.assertEqual(ct, CredentialType.USERNAME_SSH_KEY) - - def test_smime_certificate(self): - ct = CredentialType.from_string("smime_certificate") - self.assertEqual(ct, CredentialType.SMIME_CERTIFICATE) - - def test_pgp_encryption_key(self): - ct = CredentialType.from_string("pgp_encryption_key") - self.assertEqual(ct, CredentialType.PGP_ENCRYPTION_KEY) - - def test_password_only(self): - ct = CredentialType.from_string("password_only") - self.assertEqual(ct, CredentialType.PASSWORD_ONLY) diff --git a/tests/protocols/gmpv214/enums/test_entity_type.py b/tests/protocols/gmpv214/enums/test_entity_type.py deleted file mode 100644 index 7582bf02e..000000000 --- a/tests/protocols/gmpv214/enums/test_entity_type.py +++ /dev/null @@ -1,166 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import EntityType - - -class GetEntityTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - EntityType.from_string("foo") - - def test_none_or_empty(self): - ct = EntityType.from_string(None) - self.assertIsNone(ct) - ct = EntityType.from_string("") - self.assertIsNone(ct) - - def test_audit(self): - ct = EntityType.from_string("audit") - self.assertEqual(ct, EntityType.AUDIT) - - def test_alert(self): - ct = EntityType.from_string("alert") - self.assertEqual(ct, EntityType.ALERT) - - def test_asset(self): - ct = EntityType.from_string("asset") - self.assertEqual(ct, EntityType.ASSET) - - def test_cert_bund_adv(self): - ct = EntityType.from_string("cert_bund_adv") - self.assertEqual(ct, EntityType.CERT_BUND_ADV) - - def test_cpe(self): - ct = EntityType.from_string("cpe") - self.assertEqual(ct, EntityType.CPE) - - def test_credential(self): - ct = EntityType.from_string("credential") - self.assertEqual(ct, EntityType.CREDENTIAL) - - def test_dfn_cert_adv(self): - ct = EntityType.from_string("dfn_cert_adv") - self.assertEqual(ct, EntityType.DFN_CERT_ADV) - - def test_filter(self): - ct = EntityType.from_string("filter") - self.assertEqual(ct, EntityType.FILTER) - - def test_group(self): - ct = EntityType.from_string("group") - self.assertEqual(ct, EntityType.GROUP) - - def test_host(self): - ct = EntityType.from_string("host") - self.assertEqual(ct, EntityType.HOST) - - def test_info(self): - ct = EntityType.from_string("info") - self.assertEqual(ct, EntityType.INFO) - - def test_note(self): - ct = EntityType.from_string("note") - self.assertEqual(ct, EntityType.NOTE) - - def test_nvt(self): - ct = EntityType.from_string("nvt") - self.assertEqual(ct, EntityType.NVT) - - def test_operating_system(self): - ct = EntityType.from_string("os") - self.assertEqual(ct, EntityType.OPERATING_SYSTEM) - - ct = EntityType.from_string("operating_system") - self.assertEqual(ct, EntityType.OPERATING_SYSTEM) - - def test_ovaldef(self): - ct = EntityType.from_string("ovaldef") - self.assertEqual(ct, EntityType.OVALDEF) - - def test_override(self): - ct = EntityType.from_string("override") - self.assertEqual(ct, EntityType.OVERRIDE) - - def test_permission(self): - ct = EntityType.from_string("permission") - self.assertEqual(ct, EntityType.PERMISSION) - - def test_policy(self): - ct = EntityType.from_string("policy") - self.assertEqual(ct, EntityType.POLICY) - - def test_port_list(self): - ct = EntityType.from_string("port_list") - self.assertEqual(ct, EntityType.PORT_LIST) - - def test_report(self): - ct = EntityType.from_string("report") - self.assertEqual(ct, EntityType.REPORT) - - def test_report_format(self): - ct = EntityType.from_string("report_format") - self.assertEqual(ct, EntityType.REPORT_FORMAT) - - def test_result(self): - ct = EntityType.from_string("result") - self.assertEqual(ct, EntityType.RESULT) - - def test_role(self): - ct = EntityType.from_string("role") - self.assertEqual(ct, EntityType.ROLE) - - def test_scan_config(self): - ct = EntityType.from_string("config") - self.assertEqual(ct, EntityType.SCAN_CONFIG) - - ct = EntityType.from_string("scan_config") - self.assertEqual(ct, EntityType.SCAN_CONFIG) - - def test_scanner(self): - ct = EntityType.from_string("scanner") - self.assertEqual(ct, EntityType.SCANNER) - - def test_schedule(self): - ct = EntityType.from_string("schedule") - self.assertEqual(ct, EntityType.SCHEDULE) - - def test_tag(self): - ct = EntityType.from_string("tag") - self.assertEqual(ct, EntityType.TAG) - - def test_target(self): - ct = EntityType.from_string("target") - self.assertEqual(ct, EntityType.TARGET) - - def test_task(self): - ct = EntityType.from_string("task") - self.assertEqual(ct, EntityType.TASK) - - def test_ticket(self): - ct = EntityType.from_string("ticket") - self.assertEqual(ct, EntityType.TICKET) - - def test_tls_certificate(self): - ft = EntityType.from_string("tls_certificate") - self.assertEqual(ft, EntityType.TLS_CERTIFICATE) - - def test_user(self): - ct = EntityType.from_string("user") - self.assertEqual(ct, EntityType.USER) - - def test_vulnerability(self): - ct = EntityType.from_string("vuln") - self.assertEqual(ct, EntityType.VULNERABILITY) - - ct = EntityType.from_string("vulnerability") - self.assertEqual(ct, EntityType.VULNERABILITY) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_feed_type.py b/tests/protocols/gmpv214/enums/test_feed_type.py deleted file mode 100644 index e9ddda256..000000000 --- a/tests/protocols/gmpv214/enums/test_feed_type.py +++ /dev/null @@ -1,41 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import FeedType - - -class GetFeedTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - FeedType.from_string("foo") - - def test_none_or_empty(self): - ct = FeedType.from_string(None) - self.assertIsNone(ct) - ct = FeedType.from_string("") - self.assertIsNone(ct) - - def test_nvt(self): - ct = FeedType.from_string("nvt") - self.assertEqual(ct, FeedType.NVT) - - def test_cert(self): - ct = FeedType.from_string("cert") - self.assertEqual(ct, FeedType.CERT) - - def test_scap(self): - ct = FeedType.from_string("scap") - self.assertEqual(ct, FeedType.SCAP) - - def test_gvmd_data(self): - ct = FeedType.from_string("gvmd_data") - self.assertEqual(ct, FeedType.GVMD_DATA) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_filter_type.py b/tests/protocols/gmpv214/enums/test_filter_type.py deleted file mode 100644 index 905e69925..000000000 --- a/tests/protocols/gmpv214/enums/test_filter_type.py +++ /dev/null @@ -1,138 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import FilterType - - -class GetFilterTypeFomStringTestCase(unittest.TestCase): - def test_filter_type_alert(self): - ft = FilterType.from_string("alert") - self.assertEqual(ft, FilterType.ALERT) - - def test_filter_type_asset(self): - ft = FilterType.from_string("asset") - self.assertEqual(ft, FilterType.ASSET) - - def test_filter_type_credential(self): - ft = FilterType.from_string("credential") - self.assertEqual(ft, FilterType.CREDENTIAL) - - def test_filter_type_filter(self): - ft = FilterType.from_string("filter") - self.assertEqual(ft, FilterType.FILTER) - - def test_filter_type_group(self): - ft = FilterType.from_string("group") - self.assertEqual(ft, FilterType.GROUP) - - def test_filter_type_host(self): - ft = FilterType.from_string("host") - self.assertEqual(ft, FilterType.HOST) - - def test_filter_type_note(self): - ft = FilterType.from_string("note") - self.assertEqual(ft, FilterType.NOTE) - - def test_filter_type_override(self): - ft = FilterType.from_string("override") - self.assertEqual(ft, FilterType.OVERRIDE) - - def test_filter_type_permission(self): - ft = FilterType.from_string("permission") - self.assertEqual(ft, FilterType.PERMISSION) - - def test_filter_type_port_list(self): - ft = FilterType.from_string("port_list") - self.assertEqual(ft, FilterType.PORT_LIST) - - def test_filter_type_report(self): - ft = FilterType.from_string("report") - self.assertEqual(ft, FilterType.REPORT) - - def test_filter_type_report_format(self): - ft = FilterType.from_string("report_format") - self.assertEqual(ft, FilterType.REPORT_FORMAT) - - def test_filter_type_result(self): - ft = FilterType.from_string("result") - self.assertEqual(ft, FilterType.RESULT) - - def test_filter_type_role(self): - ft = FilterType.from_string("role") - self.assertEqual(ft, FilterType.ROLE) - - def test_filter_type_schedule(self): - ft = FilterType.from_string("schedule") - self.assertEqual(ft, FilterType.SCHEDULE) - - def test_filter_type_secinfo(self): - ft = FilterType.from_string("secinfo") - self.assertEqual(ft, FilterType.ALL_SECINFO) - - def test_filter_type_all_secinfo(self): - ft = FilterType.from_string("all_secinfo") - self.assertEqual(ft, FilterType.ALL_SECINFO) - - def test_filter_type_tag(self): - ft = FilterType.from_string("tag") - self.assertEqual(ft, FilterType.TAG) - - def test_filter_type_task(self): - ft = FilterType.from_string("task") - self.assertEqual(ft, FilterType.TASK) - - def test_filter_type_target(self): - ft = FilterType.from_string("target") - self.assertEqual(ft, FilterType.TARGET) - - def test_filter_type_ticket(self): - ft = FilterType.from_string("ticket") - self.assertEqual(ft, FilterType.TICKET) - - def test_filter_type_tls_certificate(self): - ft = FilterType.from_string("tls_certificate") - self.assertEqual(ft, FilterType.TLS_CERTIFICATE) - - def test_filter_type_operating_system(self): - ft = FilterType.from_string("operating_system") - self.assertEqual(ft, FilterType.OPERATING_SYSTEM) - - def test_filter_type_user(self): - ft = FilterType.from_string("user") - self.assertEqual(ft, FilterType.USER) - - def test_filter_type_vuln(self): - ft = FilterType.from_string("vuln") - self.assertEqual(ft, FilterType.VULNERABILITY) - - def test_filter_type_vulnerability(self): - ft = FilterType.from_string("vulnerability") - self.assertEqual(ft, FilterType.VULNERABILITY) - - def test_filter_type_config(self): - ft = FilterType.from_string("config") - self.assertEqual(ft, FilterType.SCAN_CONFIG) - - def test_filter_type_scan_config(self): - ft = FilterType.from_string("scan_config") - self.assertEqual(ft, FilterType.SCAN_CONFIG) - - def test_filter_type_os(self): - ft = FilterType.from_string("os") - self.assertEqual(ft, FilterType.OPERATING_SYSTEM) - - def test_invalid_filter_type(self): - with self.assertRaises(InvalidArgument): - FilterType.from_string("foo") - - def test_non_or_empty_filter_type(self): - ft = FilterType.from_string(None) - self.assertIsNone(ft) - - ft = FilterType.from_string("") - self.assertIsNone(ft) diff --git a/tests/protocols/gmpv214/enums/test_help_format.py b/tests/protocols/gmpv214/enums/test_help_format.py deleted file mode 100644 index 8f594ce77..000000000 --- a/tests/protocols/gmpv214/enums/test_help_format.py +++ /dev/null @@ -1,41 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import HelpFormat - - -class GetHelpFormatFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - HelpFormat.from_string("foo") - - def test_none_or_empty(self): - ct = HelpFormat.from_string(None) - self.assertIsNone(ct) - ct = HelpFormat.from_string("") - self.assertIsNone(ct) - - def test_task_run_status_changed(self): - ct = HelpFormat.from_string("HtMl") - self.assertEqual(ct, HelpFormat.HTML) - - def test_new_secinfo_arrived(self): - ct = HelpFormat.from_string("rNc") - self.assertEqual(ct, HelpFormat.RNC) - - def test_updated_secinfo_arrived(self): - ct = HelpFormat.from_string("tExT") - self.assertEqual(ct, HelpFormat.TEXT) - - def test_ticket_received(self): - ct = HelpFormat.from_string("XmL") - self.assertEqual(ct, HelpFormat.XML) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_hosts_ordering.py b/tests/protocols/gmpv214/enums/test_hosts_ordering.py deleted file mode 100644 index 84c0146ba..000000000 --- a/tests/protocols/gmpv214/enums/test_hosts_ordering.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import HostsOrdering - - -class GetHostsOrderingFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - HostsOrdering.from_string("foo") - - def test_none_or_empty(self): - ct = HostsOrdering.from_string(None) - self.assertIsNone(ct) - ct = HostsOrdering.from_string("") - self.assertIsNone(ct) - - def test_sequential(self): - ct = HostsOrdering.from_string("sequential") - self.assertEqual(ct, HostsOrdering.SEQUENTIAL) - - def test_random(self): - ct = HostsOrdering.from_string("random") - self.assertEqual(ct, HostsOrdering.RANDOM) - - def test_reverse(self): - ct = HostsOrdering.from_string("reverse") - self.assertEqual(ct, HostsOrdering.REVERSE) diff --git a/tests/protocols/gmpv214/enums/test_info_type.py b/tests/protocols/gmpv214/enums/test_info_type.py deleted file mode 100644 index d91dd8951..000000000 --- a/tests/protocols/gmpv214/enums/test_info_type.py +++ /dev/null @@ -1,53 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import InfoType - - -class GetInfoTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - InfoType.from_string("foo") - - def test_none_or_empty(self): - ct = InfoType.from_string(None) - self.assertIsNone(ct) - ct = InfoType.from_string("") - self.assertIsNone(ct) - - def test_cert_bund_adv(self): - ct = InfoType.from_string("cert_bund_adv") - self.assertEqual(ct, InfoType.CERT_BUND_ADV) - - def test_cpe(self): - ct = InfoType.from_string("cpe") - self.assertEqual(ct, InfoType.CPE) - - def test_cve(self): - ct = InfoType.from_string("cve") - self.assertEqual(ct, InfoType.CVE) - - def test_dfn_cert_adv(self): - ct = InfoType.from_string("dfn_cert_adv") - self.assertEqual(ct, InfoType.DFN_CERT_ADV) - - def test_nvt(self): - ct = InfoType.from_string("nvt") - self.assertEqual(ct, InfoType.NVT) - - def test_ovaldef(self): - ct = InfoType.from_string("ovaldef") - self.assertEqual(ct, InfoType.OVALDEF) - - def test_allinfo(self): - with self.assertRaises(InvalidArgument): - InfoType.from_string("allinfo") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_permission_subject_type.py b/tests/protocols/gmpv214/enums/test_permission_subject_type.py deleted file mode 100644 index e3e67d53a..000000000 --- a/tests/protocols/gmpv214/enums/test_permission_subject_type.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import PermissionSubjectType - - -class GetPermissionSubjectTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - PermissionSubjectType.from_string("foo") - - def test_none_or_empty(self): - ct = PermissionSubjectType.from_string(None) - self.assertIsNone(ct) - ct = PermissionSubjectType.from_string("") - self.assertIsNone(ct) - - def test_user(self): - ct = PermissionSubjectType.from_string("user") - self.assertEqual(ct, PermissionSubjectType.USER) - - def test_role(self): - ct = PermissionSubjectType.from_string("role") - self.assertEqual(ct, PermissionSubjectType.ROLE) - - def test_group(self): - ct = PermissionSubjectType.from_string("group") - self.assertEqual(ct, PermissionSubjectType.GROUP) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_port_range_type.py b/tests/protocols/gmpv214/enums/test_port_range_type.py deleted file mode 100644 index e4ca6f90a..000000000 --- a/tests/protocols/gmpv214/enums/test_port_range_type.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import PortRangeType - - -class GetPortRangeTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - PortRangeType.from_string("foo") - - def test_none_or_empty(self): - ct = PortRangeType.from_string(None) - self.assertIsNone(ct) - ct = PortRangeType.from_string("") - self.assertIsNone(ct) - - def test_tcp(self): - ct = PortRangeType.from_string("tcp") - self.assertEqual(ct, PortRangeType.TCP) - - def test_udp(self): - ct = PortRangeType.from_string("udp") - self.assertEqual(ct, PortRangeType.UDP) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_report_format_type.py b/tests/protocols/gmpv214/enums/test_report_format_type.py deleted file mode 100644 index 69457596d..000000000 --- a/tests/protocols/gmpv214/enums/test_report_format_type.py +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import ReportFormatType - - -class GetPortRangeTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - ReportFormatType.from_string("foo") - - def test_none_or_empty(self): - ct = ReportFormatType.from_string(None) - self.assertIsNone(ct) - ct = ReportFormatType.from_string("") - self.assertIsNone(ct) - - def test_anonymous_pdf(self): - ct = ReportFormatType.from_string("anonymous xml") - self.assertEqual(ct, ReportFormatType.ANONYMOUS_XML) - - def test_arf(self): - ct = ReportFormatType.from_string("arf") - self.assertEqual(ct, ReportFormatType.ARF) - - def test_(self): - ct = ReportFormatType.from_string("cpe") - self.assertEqual(ct, ReportFormatType.CPE) - - def test_csv_hosts(self): - ct = ReportFormatType.from_string("csv hosts") - self.assertEqual(ct, ReportFormatType.CSV_HOSTS) - - def test_csv_results(self): - ct = ReportFormatType.from_string("csv results") - self.assertEqual(ct, ReportFormatType.CSV_RESULTS) - - def test_gcr_pdf(self): - ct = ReportFormatType.from_string("gcr pdf") - self.assertEqual(ct, ReportFormatType.GCR_PDF) - - def test_gsr_html(self): - ct = ReportFormatType.from_string("gsr html") - self.assertEqual(ct, ReportFormatType.GSR_HTML) - - def test_gsr_pdf(self): - ct = ReportFormatType.from_string("gsr pdf") - self.assertEqual(ct, ReportFormatType.GSR_PDF) - - def test_gxcr_pdf(self): - ct = ReportFormatType.from_string("gxcr pdf") - self.assertEqual(ct, ReportFormatType.GXCR_PDF) - - def test_gxr_pdf(self): - ct = ReportFormatType.from_string("gxr pdf") - self.assertEqual(ct, ReportFormatType.GXR_PDF) - - def test_itg(self): - ct = ReportFormatType.from_string("itg") - self.assertEqual(ct, ReportFormatType.ITG) - - def test_latex(self): - ct = ReportFormatType.from_string("latex") - self.assertEqual(ct, ReportFormatType.LATEX) - - def test_nbe(self): - ct = ReportFormatType.from_string("nbe") - self.assertEqual(ct, ReportFormatType.NBE) - - def test_pdf(self): - ct = ReportFormatType.from_string("pdf") - self.assertEqual(ct, ReportFormatType.PDF) - - def test_svg(self): - ct = ReportFormatType.from_string("svg") - self.assertEqual(ct, ReportFormatType.SVG) - - def test_txt(self): - ct = ReportFormatType.from_string("txt") - self.assertEqual(ct, ReportFormatType.TXT) - - def test_verinice_ism(self): - ct = ReportFormatType.from_string("verinice ism") - self.assertEqual(ct, ReportFormatType.VERINICE_ISM) - - def test_verinice_itg(self): - ct = ReportFormatType.from_string("verinice itg") - self.assertEqual(ct, ReportFormatType.VERINICE_ITG) - - def test_xml(self): - ct = ReportFormatType.from_string("xml") - self.assertEqual(ct, ReportFormatType.XML) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_scanner_type.py b/tests/protocols/gmpv214/enums/test_scanner_type.py deleted file mode 100644 index 8ac4bbe36..000000000 --- a/tests/protocols/gmpv214/enums/test_scanner_type.py +++ /dev/null @@ -1,60 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import ScannerType - - -class GetScannerTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - ScannerType.from_string("foo") - - def test_none_or_empty(self): - ct = ScannerType.from_string(None) - self.assertIsNone(ct) - ct = ScannerType.from_string("") - self.assertIsNone(ct) - - def test_osp_scanner(self): - ct = ScannerType.from_string("1") - self.assertEqual(ct, ScannerType.OSP_SCANNER_TYPE) - - ct = ScannerType.from_string("osp") - self.assertEqual(ct, ScannerType.OSP_SCANNER_TYPE) - - def test_openvas_scanner(self): - ct = ScannerType.from_string("2") - self.assertEqual(ct, ScannerType.OPENVAS_SCANNER_TYPE) - - ct = ScannerType.from_string("openvas") - self.assertEqual(ct, ScannerType.OPENVAS_SCANNER_TYPE) - - def test_cve_scanner(self): - ct = ScannerType.from_string("3") - self.assertEqual(ct, ScannerType.CVE_SCANNER_TYPE) - - ct = ScannerType.from_string("cve") - self.assertEqual(ct, ScannerType.CVE_SCANNER_TYPE) - - def test_gmp_scanner(self): - with self.assertRaises(InvalidArgument): - ScannerType.from_string("4") - - with self.assertRaises(InvalidArgument): - ScannerType.from_string("gmp") - - def test_greenbone_sensor_scanner(self): - ct = ScannerType.from_string("5") - self.assertEqual(ct, ScannerType.GREENBONE_SENSOR_SCANNER_TYPE) - - ct = ScannerType.from_string("greenbone") - self.assertEqual(ct, ScannerType.GREENBONE_SENSOR_SCANNER_TYPE) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_severity_level.py b/tests/protocols/gmpv214/enums/test_severity_level.py deleted file mode 100644 index 21cc77d71..000000000 --- a/tests/protocols/gmpv214/enums/test_severity_level.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import SeverityLevel - - -class GetSeverityLevelFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SeverityLevel.from_string("foo") - - def test_none_or_empty(self): - ct = SeverityLevel.from_string(None) - self.assertIsNone(ct) - ct = SeverityLevel.from_string("") - self.assertIsNone(ct) - - def test_high(self): - ct = SeverityLevel.from_string("High") - self.assertEqual(ct, SeverityLevel.HIGH) - - def test_medium(self): - ct = SeverityLevel.from_string("Medium") - self.assertEqual(ct, SeverityLevel.MEDIUM) - - def test_low(self): - ct = SeverityLevel.from_string("Low") - self.assertEqual(ct, SeverityLevel.LOW) - - def test_log(self): - ct = SeverityLevel.from_string("Log") - self.assertEqual(ct, SeverityLevel.LOG) - - def test_alarm(self): - ct = SeverityLevel.from_string("Alarm") - self.assertEqual(ct, SeverityLevel.ALARM) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_snmp_algorithms.py b/tests/protocols/gmpv214/enums/test_snmp_algorithms.py deleted file mode 100644 index 74c8d10c6..000000000 --- a/tests/protocols/gmpv214/enums/test_snmp_algorithms.py +++ /dev/null @@ -1,49 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import SnmpAuthAlgorithm, SnmpPrivacyAlgorithm - - -class GetSnmpAuthAlgorithmFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - SnmpAuthAlgorithm.from_string("foo") - - def test_none_or_empty_type(self): - ts = SnmpAuthAlgorithm.from_string(None) - self.assertIsNone(ts) - ts = SnmpAuthAlgorithm.from_string("") - self.assertIsNone(ts) - - def test_sha1(self): - ts = SnmpAuthAlgorithm.from_string("sha1") - self.assertEqual(ts, SnmpAuthAlgorithm.SHA1) - - def test_md5(self): - ts = SnmpAuthAlgorithm.from_string("md5") - self.assertEqual(ts, SnmpAuthAlgorithm.MD5) - - -class GetSnmpPrivacyAlgorithmFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - SnmpPrivacyAlgorithm.from_string("foo") - - def test_none_or_empty_type(self): - ts = SnmpPrivacyAlgorithm.from_string(None) - self.assertIsNone(ts) - ts = SnmpPrivacyAlgorithm.from_string("") - self.assertIsNone(ts) - - def test_aes(self): - ts = SnmpPrivacyAlgorithm.from_string("aes") - self.assertEqual(ts, SnmpPrivacyAlgorithm.AES) - - def test_des(self): - ts = SnmpPrivacyAlgorithm.from_string("des") - self.assertEqual(ts, SnmpPrivacyAlgorithm.DES) diff --git a/tests/protocols/gmpv214/enums/test_sort_order.py b/tests/protocols/gmpv214/enums/test_sort_order.py deleted file mode 100644 index f37e7edb3..000000000 --- a/tests/protocols/gmpv214/enums/test_sort_order.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import SortOrder - - -class GetSortOrderFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SortOrder.from_string("foo") - - def test_none_or_empty(self): - ct = SortOrder.from_string(None) - self.assertIsNone(ct) - ct = SortOrder.from_string("") - self.assertIsNone(ct) - - def test_ascending(self): - ct = SortOrder.from_string("ascending") - self.assertEqual(ct, SortOrder.ASCENDING) - - def test_descending(self): - ct = SortOrder.from_string("descending") - self.assertEqual(ct, SortOrder.DESCENDING) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/enums/test_ticket_status.py b/tests/protocols/gmpv214/enums/test_ticket_status.py deleted file mode 100644 index fed517462..000000000 --- a/tests/protocols/gmpv214/enums/test_ticket_status.py +++ /dev/null @@ -1,33 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import TicketStatus - - -class GetTicketStatusFromStringTestCase(unittest.TestCase): - def test_invalid_status(self): - with self.assertRaises(InvalidArgument): - TicketStatus.from_string("foo") - - def test_none_or_empty_type(self): - ts = TicketStatus.from_string(None) - self.assertIsNone(ts) - ts = TicketStatus.from_string("") - self.assertIsNone(ts) - - def test_ticket_status_open(self): - ts = TicketStatus.from_string("open") - self.assertEqual(ts, TicketStatus.OPEN) - - def test_ticket_status_fixed(self): - ts = TicketStatus.from_string("fixed") - self.assertEqual(ts, TicketStatus.FIXED) - - def test_ticket_status_closed(self): - ts = TicketStatus.from_string("closed") - self.assertEqual(ts, TicketStatus.CLOSED) diff --git a/tests/protocols/gmpv214/enums/test_user_auth_type.py b/tests/protocols/gmpv214/enums/test_user_auth_type.py deleted file mode 100644 index c60451f47..000000000 --- a/tests/protocols/gmpv214/enums/test_user_auth_type.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv214 import UserAuthType - - -class GetUserAuthTypeFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - UserAuthType.from_string("foo") - - def test_none_or_empty(self): - ct = UserAuthType.from_string(None) - self.assertIsNone(ct) - ct = UserAuthType.from_string("") - self.assertIsNone(ct) - - def test_file(self): - ct = UserAuthType.from_string("file") - self.assertEqual(ct, UserAuthType.FILE) - - def test_radius_connect(self): - ct = UserAuthType.from_string("radius_connect") - self.assertEqual(ct, UserAuthType.RADIUS_CONNECT) - - def test_ldap_connect(self): - ct = UserAuthType.from_string("ldap_connect") - self.assertEqual(ct, UserAuthType.LDAP_CONNECT) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv214/system/__init__.py b/tests/protocols/gmpv214/system/__init__.py deleted file mode 100644 index bcfceaa60..000000000 --- a/tests/protocols/gmpv214/system/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# diff --git a/tests/protocols/gmpv214/system/test_aggregates.py b/tests/protocols/gmpv214/system/test_aggregates.py deleted file mode 100644 index 7097dc9f4..000000000 --- a/tests/protocols/gmpv214/system/test_aggregates.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.aggregates import GmpGetAggregatesTestMixin -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetAggregatesTestCase(GmpGetAggregatesTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/system/test_authentication.py b/tests/protocols/gmpv214/system/test_authentication.py deleted file mode 100644 index 3b49dfe97..000000000 --- a/tests/protocols/gmpv214/system/test_authentication.py +++ /dev/null @@ -1,25 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.authentication import ( - GmpAuthenticateTestMixin, - GmpDescribeAuthTestMixin, - GmpModifyAuthTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214AuthenticateTestCase(GmpAuthenticateTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214ModifyAuthTestCase(GmpModifyAuthTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214DescribeAuthCommandTestCase( - GmpDescribeAuthTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/system/test_feed.py b/tests/protocols/gmpv214/system/test_feed.py deleted file mode 100644 index 0e97f9dae..000000000 --- a/tests/protocols/gmpv214/system/test_feed.py +++ /dev/null @@ -1,15 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetFeedTestCase(GmpGetFeedTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214GetFeedsTestCase(GmpGetFeedsTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/system/test_help.py b/tests/protocols/gmpv214/system/test_help.py deleted file mode 100644 index cf31590b1..000000000 --- a/tests/protocols/gmpv214/system/test_help.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.help import GmpHelpTestMixin -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214HelpTestCase(GmpHelpTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/system/test_system_reports.py b/tests/protocols/gmpv214/system/test_system_reports.py deleted file mode 100644 index a116ae947..000000000 --- a/tests/protocols/gmpv214/system/test_system_reports.py +++ /dev/null @@ -1,13 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.system_reports import GmpGetSystemReportsTestMixin -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetSystemReportsTestCase( - GmpGetSystemReportsTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/system/test_trashcan.py b/tests/protocols/gmpv214/system/test_trashcan.py deleted file mode 100644 index 8ae1c8936..000000000 --- a/tests/protocols/gmpv214/system/test_trashcan.py +++ /dev/null @@ -1,20 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.trashcan import ( - GmpEmptyTrashcanTestMixin, - GmpRestoreFromTrashcanTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214EmptyTrashcanTestCase(GmpEmptyTrashcanTestMixin, Gmpv214TestCase): - pass - - -class Gmpv214RestoreFromTrashcanTestCase( - GmpRestoreFromTrashcanTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/system/test_user_settings.py b/tests/protocols/gmpv214/system/test_user_settings.py deleted file mode 100644 index f31de3932..000000000 --- a/tests/protocols/gmpv214/system/test_user_settings.py +++ /dev/null @@ -1,29 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.user_settings import ( - GmpGetUserSettingsTestMixin, - GmpGetUserSettingTestMixin, - GmpModifyUserSettingTestMixin, -) -from ...gmpv214 import Gmpv214TestCase - - -class Gmpv214GetUserSettingTestCase( - GmpGetUserSettingTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214GetUserSettingsTestCase( - GmpGetUserSettingsTestMixin, Gmpv214TestCase -): - pass - - -class Gmpv214ModifyUserSettingTestCase( - GmpModifyUserSettingTestMixin, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/system/test_versions.py b/tests/protocols/gmpv214/system/test_versions.py deleted file mode 100644 index fd26ceba1..000000000 --- a/tests/protocols/gmpv214/system/test_versions.py +++ /dev/null @@ -1,18 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from ...gmpv208.system.versions import GmpGetVersionTestCase -from ...gmpv214 import Gmpv214TestCase -from .versions import GmpGetProtocolVersionTestCase - - -class Gmpv214GetVersionCommandTestCase(GmpGetVersionTestCase, Gmpv214TestCase): - pass - - -class Gmpv214GmpGetProtocolVersionTestCase( - GmpGetProtocolVersionTestCase, Gmpv214TestCase -): - pass diff --git a/tests/protocols/gmpv214/system/versions/__init__.py b/tests/protocols/gmpv214/system/versions/__init__.py deleted file mode 100644 index 90764e183..000000000 --- a/tests/protocols/gmpv214/system/versions/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -# SPDX-FileCopyrightText: 2021-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from .test_get_protocol_version import GmpGetProtocolVersionTestCase - -__all__ = ("GmpGetProtocolVersionTestCase",) diff --git a/tests/protocols/gmpv214/system/versions/test_get_protocol_version.py b/tests/protocols/gmpv214/system/versions/test_get_protocol_version.py deleted file mode 100644 index 6baefa698..000000000 --- a/tests/protocols/gmpv214/system/versions/test_get_protocol_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2019-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - - -class GmpGetProtocolVersionTestCase: - def test_protocol_version(self): - self.assertEqual(self.gmp.get_protocol_version(), (21, 4)) diff --git a/tests/protocols/gmpv214/test_gmp_types.py b/tests/protocols/gmpv214/test_gmp_types.py deleted file mode 100644 index c18d9ae34..000000000 --- a/tests/protocols/gmpv214/test_gmp_types.py +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering - -from . import Gmpv214TestCase - - -class GmpWithStatementTestMixin: - def test_types(self): - with self.gmp: - # Test that the values are equal - self.assertEqual( - self.gmp.types.AlertEvent.TASK_RUN_STATUS_CHANGED.value, - "Task run status changed", - ) - self.assertEqual( - self.gmp.types.PermissionSubjectType.USER.value, "user" - ) - self.assertEqual( - self.gmp.types.HostsOrdering.RANDOM.value, "random" - ) - - # Test usability of from_string - self.assertEqual( - self.gmp.types.HostsOrdering.from_string("reverse"), - self.gmp.types.HostsOrdering.REVERSE, - ) - - # Test, that the Enum class types are equal - self.assertEqual(self.gmp.types.HostsOrdering, HostsOrdering) - - -class Gmpv214WithStatementTestCase(GmpWithStatementTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv214/test_with_statement.py b/tests/protocols/gmpv214/test_with_statement.py deleted file mode 100644 index 0341d3d1e..000000000 --- a/tests/protocols/gmpv214/test_with_statement.py +++ /dev/null @@ -1,22 +0,0 @@ -# SPDX-FileCopyrightText: 2018-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -from . import Gmpv214TestCase - - -class GmpWithStatementTestMixin: - def test_with_statement(self): - self.connection.connect.has_not_been_called() - self.connection.disconnect.has_not_been_called() - - with self.gmp: - pass - - self.connection.connect.has_been_called() - self.connection.disconnect.has_been_called() - - -class Gmpv214WithStatementTestCase(GmpWithStatementTestMixin, Gmpv214TestCase): - pass diff --git a/tests/protocols/gmpv224/__init__.py b/tests/protocols/gmpv224/__init__.py index 9a31eb4b8..0bd046fcd 100644 --- a/tests/protocols/gmpv224/__init__.py +++ b/tests/protocols/gmpv224/__init__.py @@ -4,10 +4,10 @@ # -from gvm.protocols.gmpv224 import Gmp +from gvm.protocols.gmp import GMPv224 from .. import GmpTestCase class Gmpv224TestCase(GmpTestCase): - gmp_class = Gmp + gmp_class = GMPv224 diff --git a/tests/protocols/gmpv208/entities/alerts/__init__.py b/tests/protocols/gmpv224/entities/alerts/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/alerts/__init__.py rename to tests/protocols/gmpv224/entities/alerts/__init__.py diff --git a/tests/protocols/gmpv208/entities/alerts/test_clone_alert.py b/tests/protocols/gmpv224/entities/alerts/test_clone_alert.py similarity index 89% rename from tests/protocols/gmpv208/entities/alerts/test_clone_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_clone_alert.py index 44262c57c..081f20103 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_clone_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_clone_alert.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_alert("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/alerts/test_create_alert.py b/tests/protocols/gmpv224/entities/alerts/test_create_alert.py similarity index 86% rename from tests/protocols/gmpv208/entities/alerts/test_create_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_create_alert.py index 40afa8c78..a97f8d718 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_create_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_create_alert.py @@ -3,8 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import AlertCondition, AlertEvent, AlertMethod +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( + AlertCondition, + AlertEvent, + AlertMethod, +) class GmpCreateAlertTestMixin: @@ -59,7 +63,7 @@ def test_missing_method(self): ) def test_invalid_condition(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_alert( name="foo", condition="bar", @@ -68,7 +72,7 @@ def test_invalid_condition(self): ) def test_invalid_event(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_alert( name="foo", condition=AlertCondition.ALWAYS, @@ -77,7 +81,7 @@ def test_invalid_event(self): ) def test_invalid_method(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_alert( name="foo", condition=AlertCondition.ALWAYS, @@ -309,12 +313,12 @@ def test_create_alert(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Always" - "Task run status changed" - "Email" - "" + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b"" ) def test_create_alert_with_filter_id(self): @@ -327,13 +331,13 @@ def test_create_alert_with_filter_id(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Always" - "Task run status changed" - "Email" - '' - "" + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b'' + b"" ) def test_create_alert_with_comment(self): @@ -346,13 +350,13 @@ def test_create_alert_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Always" - "Task run status changed" - "Email" - "hello" - "" + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Email" + b"hello" + b"" ) def test_create_alert_with_condition_data(self): @@ -365,12 +369,12 @@ def test_create_alert_with_condition_data(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Alwaysbarfoo" - "Task run status changed" - "Email" - "" + b"" + b"foo" + b"Alwaysbarfoo" + b"Task run status changed" + b"Email" + b"" ) def test_create_alert_with_event_data(self): @@ -383,14 +387,14 @@ def test_create_alert_with_event_data(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Always" - "Task run status changed" - "barfoo" - "" - "Email" - "" + b"" + b"foo" + b"Always" + b"Task run status changed" + b"barfoo" + b"" + b"Email" + b"" ) def test_create_alert_with_method_data(self): @@ -403,10 +407,10 @@ def test_create_alert_with_method_data(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "Always" - "Task run status changed" - "Emailbarfoo" - "" + b"" + b"foo" + b"Always" + b"Task run status changed" + b"Emailbarfoo" + b"" ) diff --git a/tests/protocols/gmpv208/entities/alerts/test_delete_alert.py b/tests/protocols/gmpv224/entities/alerts/test_delete_alert.py similarity index 85% rename from tests/protocols/gmpv208/entities/alerts/test_delete_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_delete_alert.py index 4cef4e2bd..ef371fba0 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_delete_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_delete_alert.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_alert("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_alert("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_alert_id(self): diff --git a/tests/protocols/gmpv208/entities/alerts/test_get_alert.py b/tests/protocols/gmpv224/entities/alerts/test_get_alert.py similarity index 71% rename from tests/protocols/gmpv208/entities/alerts/test_get_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_get_alert.py index da9aade57..44e6f8ccc 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_get_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_get_alert.py @@ -10,11 +10,15 @@ class GmpGetAlertTestMixin: def test_get_alert(self): self.gmp.get_alert("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_alert(alert_id="a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_alert_invalid_alert_id(self): with self.assertRaises(RequiredArgument): @@ -27,11 +31,11 @@ def test_get_alert_with_tasks(self): self.gmp.get_alert(alert_id="a1", tasks=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_alert(alert_id="a1", tasks=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/alerts/test_get_alerts.py b/tests/protocols/gmpv224/entities/alerts/test_get_alerts.py similarity index 58% rename from tests/protocols/gmpv208/entities/alerts/test_get_alerts.py rename to tests/protocols/gmpv224/entities/alerts/test_get_alerts.py index 519e12fa7..f20c3b65e 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_get_alerts.py +++ b/tests/protocols/gmpv224/entities/alerts/test_get_alerts.py @@ -8,34 +8,34 @@ class GmpGetAlertsTestMixin: def test_get_alerts(self): self.gmp.get_alerts() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_alerts_with_trash(self): self.gmp.get_alerts(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_alerts(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_alerts_with_filter_string(self): self.gmp.get_alerts(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_alerts_with_filter_id(self): self.gmp.get_alerts(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_alerts_with_tasks(self): self.gmp.get_alerts(tasks=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_alerts(tasks=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/alerts/test_modify_alert.py b/tests/protocols/gmpv224/entities/alerts/test_modify_alert.py similarity index 79% rename from tests/protocols/gmpv208/entities/alerts/test_modify_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_modify_alert.py index e951c485e..6816b1a00 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_modify_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_modify_alert.py @@ -3,8 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import AlertCondition, AlertEvent, AlertMethod +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( + AlertCondition, + AlertEvent, + AlertMethod, +) class GmpModifyAlertTestMixin: @@ -12,7 +16,7 @@ def test_modify_alert(self): self.gmp.modify_alert(alert_id="a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_alert_without_alert_id(self): @@ -29,29 +33,29 @@ def test_modify_alert_with_comment(self): self.gmp.modify_alert(alert_id="a1", comment="lorem") self.connection.send.has_been_called_with( - '' - "lorem" - "" + b'' + b"lorem" + b"" ) def test_modify_alert_with_name(self): self.gmp.modify_alert(alert_id="a1", name="lorem") self.connection.send.has_been_called_with( - '' - "lorem" - "" + b'' + b"lorem" + b"" ) def test_modify_alert_with_filter_id(self): self.gmp.modify_alert(alert_id="a1", filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_alert_invalid_condition(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_alert( alert_id="a1", condition="bar", @@ -60,7 +64,7 @@ def test_modify_alert_invalid_condition(self): ) def test_modify_alert_invalid_event(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_alert( alert_id="a1", condition=AlertCondition.ALWAYS, @@ -69,7 +73,7 @@ def test_modify_alert_invalid_event(self): ) def test_modify_alert_invalid_method(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_alert( alert_id="a1", condition=AlertCondition.ALWAYS, @@ -122,7 +126,7 @@ def test_modify_alert_with_event_missing_condition(self): ) def test_modify_alert_invalid_condition_for_secinfo(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_alert( alert_id="a1", condition="Severity at least", @@ -131,7 +135,7 @@ def test_modify_alert_invalid_condition_for_secinfo(self): ) def test_modify_alert_invalid_method_for_secinfo(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_alert( alert_id="a1", condition="Always", @@ -149,13 +153,13 @@ def test_modify_alert_with_event_data(self): ) self.connection.send.has_been_called_with( - '' - "Always" - "Email" - "Task run status changed" - "barfoo" - "" - "" + b'' + b"Always" + b"Email" + b"Task run status changed" + b"barfoo" + b"" + b"" ) def test_modify_alert_with_condition_data(self): @@ -168,11 +172,11 @@ def test_modify_alert_with_condition_data(self): ) self.connection.send.has_been_called_with( - '' - "Alwaysbarfoo" - "Email" - "Task run status changed" - "" + b'' + b"Alwaysbarfoo" + b"Email" + b"Task run status changed" + b"" ) def test_modify_alert_with_method_data(self): @@ -185,11 +189,11 @@ def test_modify_alert_with_method_data(self): ) self.connection.send.has_been_called_with( - '' - "Always" - "Emailbarfoo" - "Task run status changed" - "" + b'' + b"Always" + b"Emailbarfoo" + b"Task run status changed" + b"" ) def test_modify_missing_method_for_ticket_received(self): diff --git a/tests/protocols/gmpv208/entities/alerts/test_test_alert.py b/tests/protocols/gmpv224/entities/alerts/test_test_alert.py similarity index 80% rename from tests/protocols/gmpv208/entities/alerts/test_test_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_test_alert.py index 33fa86e3a..edc79cda5 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_test_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_test_alert.py @@ -10,7 +10,9 @@ class GmpTestAlertTestMixin: def test_test_alert(self): self.gmp.test_alert("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/alerts/test_trigger_alert.py b/tests/protocols/gmpv224/entities/alerts/test_trigger_alert.py similarity index 76% rename from tests/protocols/gmpv208/entities/alerts/test_trigger_alert.py rename to tests/protocols/gmpv224/entities/alerts/test_trigger_alert.py index 090d3cd34..cfe70e197 100644 --- a/tests/protocols/gmpv208/entities/alerts/test_trigger_alert.py +++ b/tests/protocols/gmpv224/entities/alerts/test_trigger_alert.py @@ -4,7 +4,7 @@ # from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpTriggerAlertTestMixin: @@ -26,7 +26,7 @@ def test_trigger_alert(self): self.gmp.trigger_alert(alert_id="a1", report_id="r1") self.connection.send.has_been_called_with( - '' + b'' ) def test_trigger_alert_with_filter_string(self): @@ -35,14 +35,14 @@ def test_trigger_alert_with_filter_string(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_trigger_alert_with_filter_id(self): self.gmp.trigger_alert(alert_id="a1", report_id="r1", filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_trigger_alert_with_report_format_id(self): @@ -51,7 +51,7 @@ def test_trigger_alert_with_report_format_id(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_trigger_alert_with_report_format_type(self): @@ -59,11 +59,9 @@ def test_trigger_alert_with_report_format_type(self): alert_id="a1", report_id="r1", report_format_id=ReportFormatType.SVG ) - report_format_id = ReportFormatType.from_string("svg").value - self.connection.send.has_been_called_with( - '' + b'' ) def test_trigger_alert_with_delta_report_id(self): @@ -72,5 +70,5 @@ def test_trigger_alert_with_delta_report_id(self): ) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/audits/__init__.py b/tests/protocols/gmpv224/entities/audits/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/audits/__init__.py rename to tests/protocols/gmpv224/entities/audits/__init__.py diff --git a/tests/protocols/gmpv208/entities/audits/test_clone_audit.py b/tests/protocols/gmpv224/entities/audits/test_clone_audit.py similarity index 89% rename from tests/protocols/gmpv208/entities/audits/test_clone_audit.py rename to tests/protocols/gmpv224/entities/audits/test_clone_audit.py index 9a9d34247..2dcea5e3a 100644 --- a/tests/protocols/gmpv208/entities/audits/test_clone_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_clone_audit.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_audit("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/audits/test_create_audit.py b/tests/protocols/gmpv224/entities/audits/test_create_audit.py similarity index 56% rename from tests/protocols/gmpv208/entities/audits/test_create_audit.py rename to tests/protocols/gmpv224/entities/audits/test_create_audit.py index 1bd1ceeb0..e512640a8 100644 --- a/tests/protocols/gmpv208/entities/audits/test_create_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_create_audit.py @@ -5,8 +5,8 @@ from collections import OrderedDict -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import HostsOrdering +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import HostsOrdering class GmpCreateAuditTestMixin: @@ -16,13 +16,13 @@ def test_create_audit(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"" ) def test_create_audit_missing_name(self): @@ -79,14 +79,14 @@ def test_create_audit_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "bar" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"bar" + b"" ) def test_create_audit_single_alert(self): @@ -100,14 +100,14 @@ def test_create_audit_single_alert(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - '' - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"" ) def test_create_audit_multiple_alerts(self): @@ -120,28 +120,18 @@ def test_create_audit_multiple_alerts(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - '' - '' - '' - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b'' + b'' + b"" ) - def test_create_audit_invalid_alerts(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_audit( - name="foo", - policy_id="c1", - target_id="t1", - scanner_id="s1", - alert_ids="invalid", - ) - def test_create_audit_with_empty_alert_ids(self): self.gmp.create_audit( name="foo", @@ -152,13 +142,13 @@ def test_create_audit_with_empty_alert_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"" ) def test_create_audit_with_alterable(self): @@ -171,14 +161,14 @@ def test_create_audit_with_alterable(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "1" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"1" + b"" ) self.gmp.create_audit( @@ -190,14 +180,14 @@ def test_create_audit_with_alterable(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "0" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"0" + b"" ) def test_create_audit_with_hosts_ordering(self): @@ -210,18 +200,18 @@ def test_create_audit_with_hosts_ordering(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "reverse" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"reverse" + b"" ) def test_create_audit_invalid_hosts_ordering(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_audit( name="foo", policy_id="c1", @@ -240,14 +230,14 @@ def test_create_audit_with_schedule(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - '' - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"" ) def test_create_audit_with_schedule_and_schedule_periods(self): @@ -261,15 +251,15 @@ def test_create_audit_with_schedule_and_schedule_periods(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - '' - "0" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"0" + b"" ) self.gmp.create_audit( @@ -282,15 +272,15 @@ def test_create_audit_with_schedule_and_schedule_periods(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - '' - "5" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b'' + b"5" + b"" ) def test_create_audit_with_schedule_and_invalid_schedule_periods(self): @@ -324,35 +314,16 @@ def test_create_audit_with_observers(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "u1,u2" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"u1,u2" + b"" ) - def test_create_audit_invalid_observers(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_audit( - name="foo", - policy_id="c1", - target_id="t1", - scanner_id="s1", - observers="", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_audit( - name="foo", - policy_id="c1", - target_id="t1", - scanner_id="s1", - observers="foo", - ) - def test_create_audit_with_preferences(self): self.gmp.create_audit( name="foo", @@ -363,44 +334,25 @@ def test_create_audit_with_preferences(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "audit" - '' - '' - '' - "" - "" - "foo" - "bar" - "" - "" - "lorem" - "ipsum" - "" - "" - "" + b"" + b"foo" + b"audit" + b'' + b'' + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"" ) - def test_create_audit_invalid_preferences(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_audit( - name="foo", - policy_id="c1", - target_id="t1", - scanner_id="s1", - preferences="", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_audit( - name="foo", - policy_id="c1", - target_id="t1", - scanner_id="s1", - preferences=["foo", "bar"], - ) - def test_create_audit_don_t_allow_container_task(self): with self.assertRaises(InvalidArgument): self.gmp.create_audit( diff --git a/tests/protocols/gmpv208/entities/audits/test_delete_audit.py b/tests/protocols/gmpv224/entities/audits/test_delete_audit.py similarity index 84% rename from tests/protocols/gmpv208/entities/audits/test_delete_audit.py rename to tests/protocols/gmpv224/entities/audits/test_delete_audit.py index 73ca10fc2..841a3d8c5 100644 --- a/tests/protocols/gmpv208/entities/audits/test_delete_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_delete_audit.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_audit("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_audit("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/audits/test_get_audit.py b/tests/protocols/gmpv224/entities/audits/test_get_audit.py similarity index 87% rename from tests/protocols/gmpv208/entities/audits/test_get_audit.py rename to tests/protocols/gmpv224/entities/audits/test_get_audit.py index edd94c44f..808ea20b2 100644 --- a/tests/protocols/gmpv208/entities/audits/test_get_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_get_audit.py @@ -11,7 +11,7 @@ def test_get_audit(self): self.gmp.get_audit("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_fail_without_audit_id(self): diff --git a/tests/protocols/gmpv208/entities/audits/test_get_audits.py b/tests/protocols/gmpv224/entities/audits/test_get_audits.py similarity index 74% rename from tests/protocols/gmpv208/entities/audits/test_get_audits.py rename to tests/protocols/gmpv224/entities/audits/test_get_audits.py index 8dd1d8ee8..adb4db2d4 100644 --- a/tests/protocols/gmpv208/entities/audits/test_get_audits.py +++ b/tests/protocols/gmpv224/entities/audits/test_get_audits.py @@ -9,47 +9,47 @@ def test_get_audits_simple(self): self.gmp.get_audits() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_with_filter_string(self): self.gmp.get_audits(filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_with_filter_id(self): self.gmp.get_audits(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_from_trash(self): self.gmp.get_audits(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_with_details(self): self.gmp.get_audits(details=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_without_details(self): self.gmp.get_audits(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_audits_with_schedules_only(self): self.gmp.get_audits(schedules_only=True) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/audits/test_modify_audit.py b/tests/protocols/gmpv224/entities/audits/test_modify_audit.py similarity index 56% rename from tests/protocols/gmpv208/entities/audits/test_modify_audit.py rename to tests/protocols/gmpv224/entities/audits/test_modify_audit.py index 1e61b87ac..6f60f5a40 100644 --- a/tests/protocols/gmpv208/entities/audits/test_modify_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_modify_audit.py @@ -5,15 +5,17 @@ from collections import OrderedDict -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import HostsOrdering +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import HostsOrdering class GmpModifyAuditTestMixin: def test_modify_task(self): self.gmp.modify_audit("t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_modify_audit_missing_task_id(self): with self.assertRaises(RequiredArgument): @@ -29,86 +31,79 @@ def test_modify_audit_with_name(self): self.gmp.modify_audit(audit_id="t1", name="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_audit_with_policy_id(self): self.gmp.modify_audit(audit_id="t1", policy_id="c1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_target_id(self): self.gmp.modify_audit(audit_id="t1", target_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_scanner_id(self): self.gmp.modify_audit(audit_id="t1", scanner_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_schedule_id(self): self.gmp.modify_audit(audit_id="t1", schedule_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_comment(self): self.gmp.modify_audit(audit_id="t1", comment="bar") self.connection.send.has_been_called_with( - '' - "bar" - "" + b'' + b"bar" + b"" ) def test_modify_audit_with_alerts_ids(self): self.gmp.modify_audit(audit_id="t1", alert_ids=["a1", "a2", "a3"]) self.connection.send.has_been_called_with( - '' - '' - '' - '' - "" + b'' + b'' + b'' + b'' + b"" ) - def test_modify_audit_invalid_alerts_ids(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", alert_ids="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", alert_ids="a1") - def test_modify_audit_with_empty_alert_ids(self): self.gmp.modify_audit(audit_id="t1", alert_ids=[]) self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_alterable(self): self.gmp.modify_audit(audit_id="t1", alterable=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_audit(audit_id="t1", alterable=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_audit_with_hosts_ordering(self): @@ -117,37 +112,37 @@ def test_modify_audit_with_hosts_ordering(self): ) self.connection.send.has_been_called_with( - '' - "reverse" - "" + b'' + b"reverse" + b"" ) def test_modify_audit_invalid_hosts_ordering(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_audit(audit_id="t1", hosts_ordering="foo") def test_modify_audit_with_schedule(self): self.gmp.modify_audit(audit_id="t1", schedule_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_audit_with_schedule_periods(self): self.gmp.modify_audit(audit_id="t1", schedule_periods=0) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) self.gmp.modify_audit(audit_id="t1", schedule_periods=5) self.connection.send.has_been_called_with( - '' - "5" - "" + b'' + b"5" + b"" ) def test_modify_audit_invalid_schedule_periods(self): @@ -161,18 +156,11 @@ def test_modify_audit_with_observers(self): self.gmp.modify_audit(audit_id="t1", observers=["u1", "u2"]) self.connection.send.has_been_called_with( - '' - "u1,u2" - "" + b'' + b"u1,u2" + b"" ) - def test_modify_audit_invalid_observers(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", observers="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", observers="foo") - def test_modify_audit_with_preferences(self): self.gmp.modify_audit( audit_id="t1", @@ -180,23 +168,16 @@ def test_modify_audit_with_preferences(self): ) self.connection.send.has_been_called_with( - '' - "" - "" - "foo" - "bar" - "" - "" - "lorem" - "ipsum" - "" - "" - "" + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"" ) - - def test_modify_audit_invalid_preferences(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", preferences="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_audit(audit_id="t1", preferences=["foo", "bar"]) diff --git a/tests/protocols/gmpv208/entities/audits/test_resume_audit.py b/tests/protocols/gmpv224/entities/audits/test_resume_audit.py similarity index 80% rename from tests/protocols/gmpv208/entities/audits/test_resume_audit.py rename to tests/protocols/gmpv224/entities/audits/test_resume_audit.py index 854ced0e0..130ddbfd9 100644 --- a/tests/protocols/gmpv208/entities/audits/test_resume_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_resume_audit.py @@ -10,7 +10,9 @@ class GmpResumeAuditTestMixin: def test_resume_audit(self): self.gmp.resume_audit("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/audits/test_start_audit.py b/tests/protocols/gmpv224/entities/audits/test_start_audit.py similarity index 83% rename from tests/protocols/gmpv208/entities/audits/test_start_audit.py rename to tests/protocols/gmpv224/entities/audits/test_start_audit.py index ec8176f10..497f43812 100644 --- a/tests/protocols/gmpv208/entities/audits/test_start_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_start_audit.py @@ -10,7 +10,7 @@ class GmpStartAuditTestMixin: def test_start_audit(self): self.gmp.start_audit("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/audits/test_stop_audit.py b/tests/protocols/gmpv224/entities/audits/test_stop_audit.py similarity index 83% rename from tests/protocols/gmpv208/entities/audits/test_stop_audit.py rename to tests/protocols/gmpv224/entities/audits/test_stop_audit.py index 0c8989292..7d35cbe9c 100644 --- a/tests/protocols/gmpv208/entities/audits/test_stop_audit.py +++ b/tests/protocols/gmpv224/entities/audits/test_stop_audit.py @@ -10,7 +10,7 @@ class GmpStopAuditTestMixin: def test_stop_audit(self): self.gmp.stop_audit("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/credentials/__init__.py b/tests/protocols/gmpv224/entities/credentials/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/credentials/__init__.py rename to tests/protocols/gmpv224/entities/credentials/__init__.py diff --git a/tests/protocols/gmpv208/entities/credentials/test_clone_credential.py b/tests/protocols/gmpv224/entities/credentials/test_clone_credential.py similarity index 88% rename from tests/protocols/gmpv208/entities/credentials/test_clone_credential.py rename to tests/protocols/gmpv224/entities/credentials/test_clone_credential.py index 1b309e625..6ec7bab22 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_clone_credential.py +++ b/tests/protocols/gmpv224/entities/credentials/test_clone_credential.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_credential("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/credentials/test_create_credential.py b/tests/protocols/gmpv224/entities/credentials/test_create_credential.py similarity index 66% rename from tests/protocols/gmpv208/entities/credentials/test_create_credential.py rename to tests/protocols/gmpv224/entities/credentials/test_create_credential.py index 7273c46d0..04a82dee5 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_create_credential.py +++ b/tests/protocols/gmpv224/entities/credentials/test_create_credential.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import ( +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( CredentialType, SnmpAuthAlgorithm, SnmpPrivacyAlgorithm, @@ -37,13 +37,13 @@ def test_create_up_credential(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "up" - "bar" - "Max" - "123" - "" + b"" + b"foo" + b"up" + b"bar" + b"Max" + b"123" + b"" ) def test_create_up_credential_with_allow_insecure(self): @@ -57,14 +57,14 @@ def test_create_up_credential_with_allow_insecure(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "up" - "bar" - "1" - "Max" - "123" - "" + b"" + b"foo" + b"up" + b"bar" + b"1" + b"Max" + b"123" + b"" ) self.gmp.create_credential( @@ -77,14 +77,14 @@ def test_create_up_credential_with_allow_insecure(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "up" - "bar" - "0" - "Max" - "123" - "" + b"" + b"foo" + b"up" + b"bar" + b"0" + b"Max" + b"123" + b"" ) def test_create_cc_credential_missing_certificate(self): @@ -101,11 +101,11 @@ def test_create_cc_credential(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "cc" - "abcdef" - "" + b"" + b"foo" + b"cc" + b"abcdef" + b"" ) def test_create_cc_credential_with_private_key(self): @@ -117,14 +117,14 @@ def test_create_cc_credential_with_private_key(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "cc" - "abcdef" - "" - "123456" - "" - "" + b"" + b"foo" + b"cc" + b"abcdef" + b"" + b"123456" + b"" + b"" ) def test_create_usk_credential_missing_private_key(self): @@ -152,14 +152,14 @@ def test_create_usk_credential(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "usk" - "foo" - "" - "123456" - "" - "" + b"" + b"foo" + b"usk" + b"foo" + b"" + b"123456" + b"" + b"" ) def test_create_usk_credential_with_key_phrase(self): @@ -172,24 +172,24 @@ def test_create_usk_credential_with_key_phrase(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "usk" - "foo" - "" - "123456" - "abcdef" - "" - "" + b"" + b"foo" + b"usk" + b"foo" + b"" + b"123456" + b"abcdef" + b"" + b"" ) def test_create_snmp_credential_invalid_auth_algorithm(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.create_credential( name="foo", credential_type=CredentialType.SNMP, login="foo" ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.create_credential( name="foo", credential_type=CredentialType.SNMP, @@ -197,7 +197,7 @@ def test_create_snmp_credential_invalid_auth_algorithm(self): auth_algorithm="", ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_credential( name="foo", credential_type=CredentialType.SNMP, @@ -214,12 +214,12 @@ def test_create_snmp_credential_auth_algorithm_md5(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "md5" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"md5" + b"" ) def test_create_snmp_credential_auth_algorithm_sha1(self): @@ -231,12 +231,12 @@ def test_create_snmp_credential_auth_algorithm_sha1(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "sha1" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"sha1" + b"" ) def test_create_snmp_credential_with_community(self): @@ -249,17 +249,17 @@ def test_create_snmp_credential_with_community(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "sha1" - "ipsum" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"sha1" + b"ipsum" + b"" ) def test_create_snmp_credential_invalid_privacy_algorithm(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(ValueError): self.gmp.create_credential( name="foo", credential_type=CredentialType.SNMP, @@ -268,7 +268,7 @@ def test_create_snmp_credential_invalid_privacy_algorithm(self): privacy_algorithm="", ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_credential( name="foo", credential_type=CredentialType.SNMP, @@ -287,15 +287,15 @@ def test_create_snmp_credential_with_privacy_algorithm_aes(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "sha1" - "" - "aes" - "" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"sha1" + b"" + b"aes" + b"" + b"" ) def test_create_snmp_credential_with_privacy_algorithm_des(self): @@ -308,15 +308,15 @@ def test_create_snmp_credential_with_privacy_algorithm_des(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "sha1" - "" - "des" - "" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"sha1" + b"" + b"des" + b"" + b"" ) def test_create_snmp_credential_with_privacy_password(self): @@ -329,15 +329,15 @@ def test_create_snmp_credential_with_privacy_password(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "snmp" - "foo" - "sha1" - "" - "123" - "" - "" + b"" + b"foo" + b"snmp" + b"foo" + b"sha1" + b"" + b"123" + b"" + b"" ) def test_create_smime_credential(self): @@ -348,11 +348,11 @@ def test_create_smime_credential(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "smime" - "ipsum" - "" + b"" + b"foo" + b"smime" + b"ipsum" + b"" ) def test_create_smime_credential_missing_certificate(self): @@ -369,13 +369,13 @@ def test_create_pgp_credential(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "pgp" - "" - "ipsum" - "" - "" + b"" + b"foo" + b"pgp" + b"" + b"ipsum" + b"" + b"" ) def test_create_pgp_credential_missing_public_key(self): @@ -385,13 +385,13 @@ def test_create_pgp_credential_missing_public_key(self): ) def test_create_credential_invalid_credential_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.create_credential(name="foo", credential_type=None) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.create_credential(name="foo", credential_type="") - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_credential(name="foo", credential_type="bar") def test_create_pw_credential_missing_password(self): @@ -407,9 +407,9 @@ def test_create_pw_credential(self): password="foo", ) self.connection.send.has_been_called_with( - "" - "foo" - "pw" - "foo" - "" + b"" + b"foo" + b"pw" + b"foo" + b"" ) diff --git a/tests/protocols/gmpv208/entities/credentials/test_delete_credential.py b/tests/protocols/gmpv224/entities/credentials/test_delete_credential.py similarity index 83% rename from tests/protocols/gmpv208/entities/credentials/test_delete_credential.py rename to tests/protocols/gmpv224/entities/credentials/test_delete_credential.py index efc77a378..5ecae9192 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_delete_credential.py +++ b/tests/protocols/gmpv224/entities/credentials/test_delete_credential.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_credential("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_credential("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_credential_id(self): diff --git a/tests/protocols/gmpv208/entities/credentials/test_get_credential.py b/tests/protocols/gmpv224/entities/credentials/test_get_credential.py similarity index 72% rename from tests/protocols/gmpv208/entities/credentials/test_get_credential.py rename to tests/protocols/gmpv224/entities/credentials/test_get_credential.py index c61493477..d586a2656 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_get_credential.py +++ b/tests/protocols/gmpv224/entities/credentials/test_get_credential.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import CredentialFormat +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import CredentialFormat class GmpGetCredentialTestMixin: @@ -12,7 +12,7 @@ def test_get_credential(self): self.gmp.get_credential("id") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credential_missing_credential_id(self): @@ -30,59 +30,59 @@ def test_get_credential_with_credential_format(self): self.gmp.get_credential("id", credential_format=CredentialFormat.KEY) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", credential_format=CredentialFormat.RPM) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", credential_format=CredentialFormat.DEB) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", credential_format=CredentialFormat.EXE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", credential_format=CredentialFormat.PEM) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credential_with_invalid_credential_format(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_credential("id", credential_format="foo") def test_get_credential_with_scanners(self): self.gmp.get_credential("id", scanners=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", scanners=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credential_with_targets(self): self.gmp.get_credential("id", targets=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credential("id", targets=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/credentials/test_get_credentials.py b/tests/protocols/gmpv224/entities/credentials/test_get_credentials.py similarity index 75% rename from tests/protocols/gmpv208/entities/credentials/test_get_credentials.py rename to tests/protocols/gmpv224/entities/credentials/test_get_credentials.py index ca17e8554..9a918aaa4 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_get_credentials.py +++ b/tests/protocols/gmpv224/entities/credentials/test_get_credentials.py @@ -8,57 +8,57 @@ class GmpGetCredentialsTestMixin: def test_get_credentials(self): self.gmp.get_credentials() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_credentials_with_filter_string(self): self.gmp.get_credentials(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credentials_with_filter_id(self): self.gmp.get_credentials(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credentials_with_scanners(self): self.gmp.get_credentials(scanners=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credentials(scanners=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credentials_with_trash(self): self.gmp.get_credentials(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credentials(trash=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_credentials_with_targets(self): self.gmp.get_credentials(targets=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_credentials(targets=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/credentials/test_modify_credential.py b/tests/protocols/gmpv224/entities/credentials/test_modify_credential.py similarity index 62% rename from tests/protocols/gmpv208/entities/credentials/test_modify_credential.py rename to tests/protocols/gmpv224/entities/credentials/test_modify_credential.py index 64e7f29ee..b36f244b8 100644 --- a/tests/protocols/gmpv208/entities/credentials/test_modify_credential.py +++ b/tests/protocols/gmpv224/entities/credentials/test_modify_credential.py @@ -3,8 +3,11 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import SnmpAuthAlgorithm, SnmpPrivacyAlgorithm +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ( + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, +) class GmpModifyCredentialTestMixin: @@ -12,7 +15,7 @@ def test_modify_credential(self): self.gmp.modify_credential(credential_id="c1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_credential_missing_credential_id(self): @@ -29,27 +32,27 @@ def test_modify_credential_with_name(self): self.gmp.modify_credential(credential_id="c1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_credential_with_comment(self): self.gmp.modify_credential(credential_id="c1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_credential_with_certificate(self): self.gmp.modify_credential(credential_id="c1", certificate="abcdef") self.connection.send.has_been_called_with( - '' - "abcdef" - "" + b'' + b"abcdef" + b"" ) def test_modify_credential_with_private_key_and_key_phrase(self): @@ -58,12 +61,12 @@ def test_modify_credential_with_private_key_and_key_phrase(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "123456" - "" - "" + b'' + b"" + b"foo" + b"123456" + b"" + b"" ) def test_modify_credential_missing_private_key(self): @@ -78,35 +81,35 @@ def test_modify_credential_with_allow_insecure(self): self.gmp.modify_credential(credential_id="c1", allow_insecure=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_credential(credential_id="c1", allow_insecure=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_credential_with_login(self): self.gmp.modify_credential(credential_id="c1", login="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_credential_with_password(self): self.gmp.modify_credential(credential_id="c1", password="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_credential_with_auth_algorithm(self): @@ -115,9 +118,9 @@ def test_modify_credential_with_auth_algorithm(self): ) self.connection.send.has_been_called_with( - '' - "md5" - "" + b'' + b"md5" + b"" ) self.gmp.modify_credential( @@ -125,22 +128,22 @@ def test_modify_credential_with_auth_algorithm(self): ) self.connection.send.has_been_called_with( - '' - "sha1" - "" + b'' + b"sha1" + b"" ) def test_modify_credential_invalid_auth_algorithm(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_credential(credential_id="c1", auth_algorithm="foo") def test_modify_credential_with_community(self): self.gmp.modify_credential(credential_id="c1", community="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_credential_with_privacy_algorithm(self): @@ -149,11 +152,11 @@ def test_modify_credential_with_privacy_algorithm(self): ) self.connection.send.has_been_called_with( - '' - "" - "aes" - "" - "" + b'' + b"" + b"aes" + b"" + b"" ) self.gmp.modify_credential( @@ -161,18 +164,18 @@ def test_modify_credential_with_privacy_algorithm(self): ) self.connection.send.has_been_called_with( - '' - "" - "des" - "" - "" + b'' + b"" + b"des" + b"" + b"" ) def test_modify_credential_invalid_privacy_algorithm(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(ValueError): self.gmp.modify_credential(credential_id="c1", privacy_algorithm="") - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_credential( credential_id="c1", privacy_algorithm="foo" ) @@ -181,20 +184,20 @@ def test_modify_credential_with_privacy_password(self): self.gmp.modify_credential(credential_id="c1", privacy_password="foo") self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_credential_with_public_key(self): self.gmp.modify_credential(credential_id="c1", public_key="foo") self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) diff --git a/tests/protocols/gmpv208/entities/filters/__init__.py b/tests/protocols/gmpv224/entities/filters/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/filters/__init__.py rename to tests/protocols/gmpv224/entities/filters/__init__.py diff --git a/tests/protocols/gmpv208/entities/filters/test_clone_filter.py b/tests/protocols/gmpv224/entities/filters/test_clone_filter.py similarity index 89% rename from tests/protocols/gmpv208/entities/filters/test_clone_filter.py rename to tests/protocols/gmpv224/entities/filters/test_clone_filter.py index ce93d8dfb..62c36ff11 100644 --- a/tests/protocols/gmpv208/entities/filters/test_clone_filter.py +++ b/tests/protocols/gmpv224/entities/filters/test_clone_filter.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_filter("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/filters/test_create_filter.py b/tests/protocols/gmpv224/entities/filters/test_create_filter.py similarity index 72% rename from tests/protocols/gmpv208/entities/filters/test_create_filter.py rename to tests/protocols/gmpv224/entities/filters/test_create_filter.py index d1a7799c5..e8b925a0e 100644 --- a/tests/protocols/gmpv208/entities/filters/test_create_filter.py +++ b/tests/protocols/gmpv224/entities/filters/test_create_filter.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import FilterType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import FilterType class GmpCreateFilterTestMixin: @@ -21,11 +21,11 @@ def test_all_available_filters_types_correct(self): "f1" "sort-reverse=threat first=1 rows=1000" f"{filter_type.value}" - "" + "".encode("utf-8") ) def test_create_filter_invalid_filter_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_filter( name="f1", term="sort-reverse=threat result_hosts_only=1 " @@ -42,12 +42,12 @@ def test_create_filter_no_filter_type(self): ) self.connection.send.has_been_called_with( - "" - "f1" - "foo" - "sort-reverse=threat result_hosts_only=1 notes=1 " - "overrides=1 levels=hml first=1 rows=1000" - "" + b"" + b"f1" + b"foo" + b"sort-reverse=threat result_hosts_only=1 notes=1 " + b"overrides=1 levels=hml first=1 rows=1000" + b"" ) def test_create_filter(self): @@ -60,13 +60,13 @@ def test_create_filter(self): ) self.connection.send.has_been_called_with( - "" - "f1" - "foo" - "sort-reverse=threat result_hosts_only=1 notes=1 " - "overrides=1 levels=hml first=1 rows=1000" - "task" - "" + b"" + b"f1" + b"foo" + b"sort-reverse=threat result_hosts_only=1 notes=1 " + b"overrides=1 levels=hml first=1 rows=1000" + b"task" + b"" ) def test_create_filter_without_term(self): @@ -77,11 +77,11 @@ def test_create_filter_without_term(self): ) self.connection.send.has_been_called_with( - "" - "f1" - "foo" - "task" - "" + b"" + b"f1" + b"foo" + b"task" + b"" ) def test_create_filter_make_unique(self): diff --git a/tests/protocols/gmpv208/entities/filters/test_delete_filter.py b/tests/protocols/gmpv224/entities/filters/test_delete_filter.py similarity index 84% rename from tests/protocols/gmpv208/entities/filters/test_delete_filter.py rename to tests/protocols/gmpv224/entities/filters/test_delete_filter.py index 3bbaa2df5..d91dc2222 100644 --- a/tests/protocols/gmpv208/entities/filters/test_delete_filter.py +++ b/tests/protocols/gmpv224/entities/filters/test_delete_filter.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_filter("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_filter("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_filter_id(self): diff --git a/tests/protocols/gmpv208/entities/filters/test_get_filter.py b/tests/protocols/gmpv224/entities/filters/test_get_filter.py similarity index 82% rename from tests/protocols/gmpv208/entities/filters/test_get_filter.py rename to tests/protocols/gmpv224/entities/filters/test_get_filter.py index ce94422ce..feb6efc86 100644 --- a/tests/protocols/gmpv208/entities/filters/test_get_filter.py +++ b/tests/protocols/gmpv224/entities/filters/test_get_filter.py @@ -11,13 +11,13 @@ def test_get_filter(self): self.gmp.get_filter("f1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_filter(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_filter_missing_filter_id(self): @@ -31,11 +31,11 @@ def test_get_filter_with_alerts(self): self.gmp.get_filter(filter_id="f1", alerts=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_filter(filter_id="f1", alerts=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/filters/test_get_filters.py b/tests/protocols/gmpv224/entities/filters/test_get_filters.py similarity index 57% rename from tests/protocols/gmpv208/entities/filters/test_get_filters.py rename to tests/protocols/gmpv224/entities/filters/test_get_filters.py index 464caf6f0..018381e42 100644 --- a/tests/protocols/gmpv208/entities/filters/test_get_filters.py +++ b/tests/protocols/gmpv224/entities/filters/test_get_filters.py @@ -8,34 +8,36 @@ class GmpGetFiltersTestMixin: def test_get_filters(self): self.gmp.get_filters() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_filters_with_filter_string(self): self.gmp.get_filters(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_filters_with_filter_id(self): self.gmp.get_filters(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_filters_with_trash(self): self.gmp.get_filters(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_filters(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_filters_with_alerts(self): self.gmp.get_filters(alerts=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_filters(alerts=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/filters/test_modify_filter.py b/tests/protocols/gmpv224/entities/filters/test_modify_filter.py similarity index 68% rename from tests/protocols/gmpv208/entities/filters/test_modify_filter.py rename to tests/protocols/gmpv224/entities/filters/test_modify_filter.py index f8c129a9f..a0e6fe39a 100644 --- a/tests/protocols/gmpv208/entities/filters/test_modify_filter.py +++ b/tests/protocols/gmpv224/entities/filters/test_modify_filter.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import FilterType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import FilterType class GmpModifyFilterTestMixin: @@ -12,20 +12,20 @@ def test_modify_filter(self): self.gmp.modify_filter(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_filter_with_filter_type(self): self.gmp.modify_filter(filter_id="f1", filter_type=FilterType.TASK) self.connection.send.has_been_called_with( - '' - "task" - "" + b'' + b"task" + b"" ) def test_modify_filter_invalid_filter_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_filter(filter_id="f1", filter_type="foo") def test_modify_filter_missing_filter_id(self): @@ -42,25 +42,25 @@ def test_modify_filter_with_comment(self): self.gmp.modify_filter(filter_id="f1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_filter_with_name(self): self.gmp.modify_filter(filter_id="f1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_filter_with_term(self): self.gmp.modify_filter(filter_id="f1", term="foo=bar") self.connection.send.has_been_called_with( - '' - "foo=bar" - "" + b'' + b"foo=bar" + b"" ) diff --git a/tests/protocols/gmpv208/entities/groups/__init__.py b/tests/protocols/gmpv224/entities/groups/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/groups/__init__.py rename to tests/protocols/gmpv224/entities/groups/__init__.py diff --git a/tests/protocols/gmpv208/entities/groups/test_clone_group.py b/tests/protocols/gmpv224/entities/groups/test_clone_group.py similarity index 89% rename from tests/protocols/gmpv208/entities/groups/test_clone_group.py rename to tests/protocols/gmpv224/entities/groups/test_clone_group.py index bbd52c97f..d16a3c180 100644 --- a/tests/protocols/gmpv208/entities/groups/test_clone_group.py +++ b/tests/protocols/gmpv224/entities/groups/test_clone_group.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_group("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/groups/test_create_group.py b/tests/protocols/gmpv224/entities/groups/test_create_group.py similarity index 67% rename from tests/protocols/gmpv208/entities/groups/test_create_group.py rename to tests/protocols/gmpv224/entities/groups/test_create_group.py index 80f8ecfde..576fdd7c9 100644 --- a/tests/protocols/gmpv208/entities/groups/test_create_group.py +++ b/tests/protocols/gmpv224/entities/groups/test_create_group.py @@ -11,7 +11,7 @@ def test_create_group(self): self.gmp.create_group(name="foo") self.connection.send.has_been_called_with( - "foo" + b"foo" ) def test_missing_name(self): @@ -25,36 +25,36 @@ def test_create_group_with_comment(self): self.gmp.create_group(name="foo", comment="bar") self.connection.send.has_been_called_with( - "" - "foo" - "bar" - "" + b"" + b"foo" + b"bar" + b"" ) def test_create_special_group(self): self.gmp.create_group(name="foo", special=True) self.connection.send.has_been_called_with( - "" - "foo" - "" - "" - "" - "" + b"" + b"foo" + b"" + b"" + b"" + b"" ) def test_create_group_with_users(self): self.gmp.create_group(name="foo", users=[]) self.connection.send.has_been_called_with( - "foo" + b"foo" ) self.gmp.create_group(name="foo", users=["u1", "u2"]) self.connection.send.has_been_called_with( - "" - "foo" - "u1,u2" - "" + b"" + b"foo" + b"u1,u2" + b"" ) diff --git a/tests/protocols/gmpv208/entities/groups/test_delete_group.py b/tests/protocols/gmpv224/entities/groups/test_delete_group.py similarity index 84% rename from tests/protocols/gmpv208/entities/groups/test_delete_group.py rename to tests/protocols/gmpv224/entities/groups/test_delete_group.py index 5e3406c76..b7d3a5a4a 100644 --- a/tests/protocols/gmpv208/entities/groups/test_delete_group.py +++ b/tests/protocols/gmpv224/entities/groups/test_delete_group.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_group("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_group("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_group_id(self): diff --git a/tests/protocols/gmpv208/entities/groups/test_get_group.py b/tests/protocols/gmpv224/entities/groups/test_get_group.py similarity index 70% rename from tests/protocols/gmpv208/entities/groups/test_get_group.py rename to tests/protocols/gmpv224/entities/groups/test_get_group.py index 6c19945a8..d96e0ed09 100644 --- a/tests/protocols/gmpv208/entities/groups/test_get_group.py +++ b/tests/protocols/gmpv224/entities/groups/test_get_group.py @@ -10,11 +10,15 @@ class GmpGetGroupTestMixin: def test_get_group(self): self.gmp.get_group("f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_group(group_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_group_missing_group_id(self): with self.assertRaises(RequiredArgument): diff --git a/tests/protocols/gmpv208/entities/groups/test_get_groups.py b/tests/protocols/gmpv224/entities/groups/test_get_groups.py similarity index 62% rename from tests/protocols/gmpv208/entities/groups/test_get_groups.py rename to tests/protocols/gmpv224/entities/groups/test_get_groups.py index 0fea685b8..b2faa9383 100644 --- a/tests/protocols/gmpv208/entities/groups/test_get_groups.py +++ b/tests/protocols/gmpv224/entities/groups/test_get_groups.py @@ -8,25 +8,25 @@ class GmpGetGroupsTestMixin: def test_get_groups(self): self.gmp.get_groups() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_groups_with_filter_string(self): self.gmp.get_groups(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_groups_with_filter_id(self): self.gmp.get_groups(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_groups_with_trash(self): self.gmp.get_groups(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_groups(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/groups/test_modify_group.py b/tests/protocols/gmpv224/entities/groups/test_modify_group.py similarity index 73% rename from tests/protocols/gmpv208/entities/groups/test_modify_group.py rename to tests/protocols/gmpv224/entities/groups/test_modify_group.py index 217f4fafa..97fda794b 100644 --- a/tests/protocols/gmpv208/entities/groups/test_modify_group.py +++ b/tests/protocols/gmpv224/entities/groups/test_modify_group.py @@ -11,7 +11,7 @@ def test_modify_group(self): self.gmp.modify_group(group_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_group_missing_group_id(self): @@ -28,31 +28,31 @@ def test_modify_group_with_comment(self): self.gmp.modify_group(group_id="f1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_group_with_name(self): self.gmp.modify_group(group_id="f1", name="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_group_with_users(self): self.gmp.modify_group(group_id="f1", users=["foo"]) self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_group(group_id="f1", users=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - "foo,bar" - "" + b'' + b"foo,bar" + b"" ) diff --git a/tests/protocols/gmpv208/entities/hosts/__init__.py b/tests/protocols/gmpv224/entities/hosts/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/hosts/__init__.py rename to tests/protocols/gmpv224/entities/hosts/__init__.py diff --git a/tests/protocols/gmpv208/entities/hosts/test_create_host.py b/tests/protocols/gmpv224/entities/hosts/test_create_host.py similarity index 64% rename from tests/protocols/gmpv208/entities/hosts/test_create_host.py rename to tests/protocols/gmpv224/entities/hosts/test_create_host.py index e8428d249..d1f79a41f 100644 --- a/tests/protocols/gmpv208/entities/hosts/test_create_host.py +++ b/tests/protocols/gmpv224/entities/hosts/test_create_host.py @@ -18,23 +18,23 @@ def test_create_host_asset(self): self.gmp.create_host(name="ipsum") self.connection.send.has_been_called_with( - "" - "" - "host" - "ipsum" - "" - "" + b"" + b"" + b"host" + b"ipsum" + b"" + b"" ) def test_create_asset_with_comment(self): self.gmp.create_host(name="ipsum", comment="lorem") self.connection.send.has_been_called_with( - "" - "" - "host" - "ipsum" - "lorem" - "" - "" + b"" + b"" + b"host" + b"ipsum" + b"lorem" + b"" + b"" ) diff --git a/tests/protocols/gmpv208/entities/hosts/test_delete_host.py b/tests/protocols/gmpv224/entities/hosts/test_delete_host.py similarity index 90% rename from tests/protocols/gmpv208/entities/hosts/test_delete_host.py rename to tests/protocols/gmpv224/entities/hosts/test_delete_host.py index 5c4da02e1..ff5f21ba3 100644 --- a/tests/protocols/gmpv208/entities/hosts/test_delete_host.py +++ b/tests/protocols/gmpv224/entities/hosts/test_delete_host.py @@ -11,7 +11,7 @@ def test_delete_host(self): self.gmp.delete_host(host_id="a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_arguments(self): diff --git a/tests/protocols/gmpv208/entities/hosts/test_get_host.py b/tests/protocols/gmpv224/entities/hosts/test_get_host.py similarity index 79% rename from tests/protocols/gmpv208/entities/hosts/test_get_host.py rename to tests/protocols/gmpv224/entities/hosts/test_get_host.py index 09d5305f3..f9c0834f1 100644 --- a/tests/protocols/gmpv208/entities/hosts/test_get_host.py +++ b/tests/protocols/gmpv224/entities/hosts/test_get_host.py @@ -11,26 +11,26 @@ def test_get_host(self): self.gmp.get_host("a1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_host(host_id="a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_host_details(self): self.gmp.get_host("a1", details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_host("a1", details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_host_missing_host_id(self): diff --git a/tests/protocols/gmpv208/entities/hosts/test_get_hosts.py b/tests/protocols/gmpv224/entities/hosts/test_get_hosts.py similarity index 71% rename from tests/protocols/gmpv208/entities/hosts/test_get_hosts.py rename to tests/protocols/gmpv224/entities/hosts/test_get_hosts.py index 8c6830f8d..258f9a0b6 100644 --- a/tests/protocols/gmpv208/entities/hosts/test_get_hosts.py +++ b/tests/protocols/gmpv224/entities/hosts/test_get_hosts.py @@ -8,31 +8,31 @@ class GmpGetHostsTestMixin: def test_get_hosts(self): self.gmp.get_hosts() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_hosts_details(self): self.gmp.get_hosts(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_hosts(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_hosts_with_filter_string(self): self.gmp.get_hosts(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_hosts_with_filter_id(self): self.gmp.get_hosts(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/hosts/test_modify_host.py b/tests/protocols/gmpv224/entities/hosts/test_modify_host.py similarity index 67% rename from tests/protocols/gmpv208/entities/hosts/test_modify_host.py rename to tests/protocols/gmpv224/entities/hosts/test_modify_host.py index f5c6d378c..7e3b26d2d 100644 --- a/tests/protocols/gmpv208/entities/hosts/test_modify_host.py +++ b/tests/protocols/gmpv224/entities/hosts/test_modify_host.py @@ -11,9 +11,9 @@ def test_modify_host(self): self.gmp.modify_host(host_id="a1") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) def test_modify_host_without_host_id(self): @@ -30,31 +30,31 @@ def test_modify_host_with_comment(self): self.gmp.modify_host("a1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_host("a1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_host("a1", comment="") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) self.gmp.modify_host("a1", comment=None) self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) diff --git a/tests/protocols/gmpv224/entities/notes/__init__.py b/tests/protocols/gmpv224/entities/notes/__init__.py index 5ade3a35f..7fb62081e 100644 --- a/tests/protocols/gmpv224/entities/notes/__init__.py +++ b/tests/protocols/gmpv224/entities/notes/__init__.py @@ -3,7 +3,18 @@ # SPDX-License-Identifier: GPL-3.0-or-later # +from .test_clone_note import GmpCloneNoteTestMixin from .test_create_note import GmpCreateNoteTestMixin +from .test_delete_note import GmpDeleteNoteTestMixin +from .test_get_note import GmpGetNoteTestMixin +from .test_get_notes import GmpGetNotesTestMixin from .test_modify_note import GmpModifyNoteTestMixin -__all__ = ("GmpCreateNoteTestMixin", "GmpModifyNoteTestMixin") +__all__ = ( + "GmpCloneNoteTestMixin", + "GmpCreateNoteTestMixin", + "GmpDeleteNoteTestMixin", + "GmpGetNoteTestMixin", + "GmpGetNotesTestMixin", + "GmpModifyNoteTestMixin", +) diff --git a/tests/protocols/gmpv208/entities/notes/test_clone_note.py b/tests/protocols/gmpv224/entities/notes/test_clone_note.py similarity index 89% rename from tests/protocols/gmpv208/entities/notes/test_clone_note.py rename to tests/protocols/gmpv224/entities/notes/test_clone_note.py index b41059e04..f7cd19e87 100644 --- a/tests/protocols/gmpv208/entities/notes/test_clone_note.py +++ b/tests/protocols/gmpv224/entities/notes/test_clone_note.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_note("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/notes/test_create_note.py b/tests/protocols/gmpv224/entities/notes/test_create_note.py index 96b5e4f7f..100eccfff 100644 --- a/tests/protocols/gmpv224/entities/notes/test_create_note.py +++ b/tests/protocols/gmpv224/entities/notes/test_create_note.py @@ -6,7 +6,6 @@ from decimal import Decimal from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv224 import SeverityLevel class GmpCreateNoteTestMixin: @@ -14,10 +13,10 @@ def test_create_note(self): self.gmp.create_note("foo", nvt_oid="oid1") self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) def test_create_note_missing_text(self): @@ -38,125 +37,115 @@ def test_create_note_with_hosts(self): self.gmp.create_note("foo", nvt_oid="oid1", hosts=[]) self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) self.gmp.create_note("foo", nvt_oid="oid1", hosts=["h1", "h2"]) self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" + b"" + b"foo" + b'' + b"h1,h2" + b"" ) def test_create_note_with_port(self): self.gmp.create_note("foo", nvt_oid="oid1", port="666/tcp") self.connection.send.has_been_called_with( - "" - "foo" - '' - "666/tcp" - "" + b"" + b"foo" + b'' + b"666/tcp" + b"" ) def test_create_note_with_result_id(self): self.gmp.create_note("foo", nvt_oid="oid1", result_id="r1") self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" + b"" + b"foo" + b'' + b'' + b"" ) def test_create_note_with_task_id(self): self.gmp.create_note("foo", nvt_oid="oid1", task_id="t1") self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" + b"" + b"foo" + b'' + b'' + b"" ) def test_create_note_with_severity(self): self.gmp.create_note("foo", nvt_oid="oid1", severity="5.5") self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_note("foo", nvt_oid="oid1", severity=5.5) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_note("foo", nvt_oid="oid1", severity=Decimal(5.5)) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_note_with_threat(self): - self.gmp.create_note("foo", nvt_oid="oid1", threat=SeverityLevel.HIGH) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) def test_create_note_with_days_active(self): self.gmp.create_note("foo", nvt_oid="oid1", days_active=0) self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" + b"" + b"foo" + b'' + b"0" + b"" ) self.gmp.create_note("foo", nvt_oid="oid1", days_active=-1) self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" + b"" + b"foo" + b'' + b"-1" + b"" ) self.gmp.create_note("foo", nvt_oid="oid1", days_active=3600) self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" + b"" + b"foo" + b'' + b"3600" + b"" ) def test_create_note_with_invalid_port(self): diff --git a/tests/protocols/gmpv208/entities/notes/test_delete_note.py b/tests/protocols/gmpv224/entities/notes/test_delete_note.py similarity index 84% rename from tests/protocols/gmpv208/entities/notes/test_delete_note.py rename to tests/protocols/gmpv224/entities/notes/test_delete_note.py index 96433c07c..3563c1c2d 100644 --- a/tests/protocols/gmpv208/entities/notes/test_delete_note.py +++ b/tests/protocols/gmpv224/entities/notes/test_delete_note.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_note("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_note("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/notes/test_get_note.py b/tests/protocols/gmpv224/entities/notes/test_get_note.py similarity index 85% rename from tests/protocols/gmpv208/entities/notes/test_get_note.py rename to tests/protocols/gmpv224/entities/notes/test_get_note.py index d4d1636eb..bbd431024 100644 --- a/tests/protocols/gmpv208/entities/notes/test_get_note.py +++ b/tests/protocols/gmpv224/entities/notes/test_get_note.py @@ -11,13 +11,13 @@ def test_get_note(self): self.gmp.get_note("n1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_note(note_id="n1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_note_missing_note_id(self): diff --git a/tests/protocols/gmpv208/entities/notes/test_get_notes.py b/tests/protocols/gmpv224/entities/notes/test_get_notes.py similarity index 57% rename from tests/protocols/gmpv208/entities/notes/test_get_notes.py rename to tests/protocols/gmpv224/entities/notes/test_get_notes.py index efd2ce1dd..6c8b0cde1 100644 --- a/tests/protocols/gmpv208/entities/notes/test_get_notes.py +++ b/tests/protocols/gmpv224/entities/notes/test_get_notes.py @@ -8,34 +8,34 @@ class GmpGetNotesTestMixin: def test_get_notes(self): self.gmp.get_notes() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_notes_with_filter_string(self): self.gmp.get_notes(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_notes_with_filter_id(self): self.gmp.get_notes(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_notes_with_details(self): self.gmp.get_notes(details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_notes(details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_notes_with_result(self): self.gmp.get_notes(result=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_notes(result=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv224/entities/notes/test_modify_note.py b/tests/protocols/gmpv224/entities/notes/test_modify_note.py index fc6611347..b97b53fb3 100644 --- a/tests/protocols/gmpv224/entities/notes/test_modify_note.py +++ b/tests/protocols/gmpv224/entities/notes/test_modify_note.py @@ -6,7 +6,6 @@ from decimal import Decimal from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv224 import SeverityLevel class GmpModifyNoteTestMixin: @@ -14,7 +13,7 @@ def test_modify_note(self): self.gmp.modify_note(note_id="n1", text="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_note_missing_note_id(self): @@ -41,114 +40,105 @@ def test_modify_note_with_days_active(self): self.gmp.modify_note(note_id="n1", text="foo", days_active=0) self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" + b'' + b"foo" + b"0" + b"" ) self.gmp.modify_note(note_id="n1", text="foo", days_active=-1) self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" + b'' + b"foo" + b"-1" + b"" ) self.gmp.modify_note(note_id="n1", text="foo", days_active=600) self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" + b'' + b"foo" + b"600" + b"" ) def test_modify_note_with_port(self): self.gmp.modify_note(note_id="n1", text="foo", port="123/tcp") self.connection.send.has_been_called_with( - '' - "foo" - "123/tcp" - "" + b'' + b"foo" + b"123/tcp" + b"" ) def test_modify_note_with_hosts(self): self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo"]) self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" + b'' + b"foo" + b"foo" + b"" ) self.gmp.modify_note(note_id="n1", text="foo", hosts=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" + b'' + b"foo" + b"foo,bar" + b"" ) def test_modify_note_with_result_id(self): self.gmp.modify_note(note_id="n1", text="foo", result_id="r1") self.connection.send.has_been_called_with( - '' - "foo" - '' - "" + b'' + b"foo" + b'' + b"" ) def test_modify_note_with_task_id(self): self.gmp.modify_note(note_id="n1", text="foo", task_id="r1") self.connection.send.has_been_called_with( - '' - "foo" - '' - "" + b'' + b"foo" + b'' + b"" ) def test_modify_note_with_severity(self): self.gmp.modify_note(note_id="n1", text="foo", severity="5.5") self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_note(note_id="n1", text="foo", severity=5.5) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_note(note_id="n1", text="foo", severity=Decimal(5.5)) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_note_with_threat(self): - self.gmp.modify_note( - note_id="n1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - 'foo' + b'' + b"foo" + b"5.5" + b"" ) def test_modify_note_with_invalid_port(self): diff --git a/tests/protocols/gmpv208/entities/operating_systems/__init__.py b/tests/protocols/gmpv224/entities/operating_systems/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/operating_systems/__init__.py rename to tests/protocols/gmpv224/entities/operating_systems/__init__.py diff --git a/tests/protocols/gmpv208/entities/operating_systems/test_delete_operating_system.py b/tests/protocols/gmpv224/entities/operating_systems/test_delete_operating_system.py similarity index 91% rename from tests/protocols/gmpv208/entities/operating_systems/test_delete_operating_system.py rename to tests/protocols/gmpv224/entities/operating_systems/test_delete_operating_system.py index 16e8e7480..104a1a5a8 100644 --- a/tests/protocols/gmpv208/entities/operating_systems/test_delete_operating_system.py +++ b/tests/protocols/gmpv224/entities/operating_systems/test_delete_operating_system.py @@ -11,7 +11,7 @@ def test_delete_operating_system(self): self.gmp.delete_operating_system(operating_system_id="a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_arguments(self): diff --git a/tests/protocols/gmpv208/entities/operating_systems/test_get_operating_system.py b/tests/protocols/gmpv224/entities/operating_systems/test_get_operating_system.py similarity index 81% rename from tests/protocols/gmpv208/entities/operating_systems/test_get_operating_system.py rename to tests/protocols/gmpv224/entities/operating_systems/test_get_operating_system.py index 017636769..554f1a22e 100644 --- a/tests/protocols/gmpv208/entities/operating_systems/test_get_operating_system.py +++ b/tests/protocols/gmpv224/entities/operating_systems/test_get_operating_system.py @@ -11,24 +11,24 @@ def test_get_operating_system(self): self.gmp.get_operating_system("a1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_operating_system(operating_system_id="a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_operating_system_details(self): self.gmp.get_operating_system("a1", details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_operating_system("a1", details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_asset_missing_operating_system_id(self): diff --git a/tests/protocols/gmpv208/entities/operating_systems/test_get_operating_systems.py b/tests/protocols/gmpv224/entities/operating_systems/test_get_operating_systems.py similarity index 75% rename from tests/protocols/gmpv208/entities/operating_systems/test_get_operating_systems.py rename to tests/protocols/gmpv224/entities/operating_systems/test_get_operating_systems.py index 802ee97e9..5ddae109a 100644 --- a/tests/protocols/gmpv208/entities/operating_systems/test_get_operating_systems.py +++ b/tests/protocols/gmpv224/entities/operating_systems/test_get_operating_systems.py @@ -8,31 +8,31 @@ class GmpGetOperatingSystemsTestMixin: def test_get_operating_systems(self): self.gmp.get_operating_systems() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_operating_systems_details(self): self.gmp.get_operating_systems(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_operating_systems(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_operating_systems_with_filter_string(self): self.gmp.get_operating_systems(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_operating_systems_with_filter_id(self): self.gmp.get_operating_systems(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/operating_systems/test_modify_operating_system.py b/tests/protocols/gmpv224/entities/operating_systems/test_modify_operating_system.py similarity index 71% rename from tests/protocols/gmpv208/entities/operating_systems/test_modify_operating_system.py rename to tests/protocols/gmpv224/entities/operating_systems/test_modify_operating_system.py index 7f1f10804..b76eacd56 100644 --- a/tests/protocols/gmpv208/entities/operating_systems/test_modify_operating_system.py +++ b/tests/protocols/gmpv224/entities/operating_systems/test_modify_operating_system.py @@ -11,9 +11,9 @@ def test_modify_operating_system(self): self.gmp.modify_operating_system(operating_system_id="a1") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) def test_modify_operating_system_without_operating_system_id(self): @@ -34,31 +34,31 @@ def test_modify_operating_system_with_comment(self): self.gmp.modify_operating_system("a1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_operating_system("a1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_operating_system("a1", comment="") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) self.gmp.modify_operating_system("a1", comment=None) self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) diff --git a/tests/protocols/gmpv224/entities/overrides/__init__.py b/tests/protocols/gmpv224/entities/overrides/__init__.py index 9784893cf..3dd4e1978 100644 --- a/tests/protocols/gmpv224/entities/overrides/__init__.py +++ b/tests/protocols/gmpv224/entities/overrides/__init__.py @@ -3,7 +3,18 @@ # SPDX-License-Identifier: GPL-3.0-or-later # +from .test_clone_override import GmpCloneOverrideTestMixin from .test_create_override import GmpCreateOverrideTestMixin +from .test_delete_override import GmpDeleteOverrideTestMixin +from .test_get_override import GmpGetOverrideTestMixin +from .test_get_overrides import GmpGetOverridesTestMixin from .test_modify_override import GmpModifyOverrideTestMixin -__all__ = ("GmpCreateOverrideTestMixin", "GmpModifyOverrideTestMixin") +__all__ = ( + "GmpCloneOverrideTestMixin", + "GmpCreateOverrideTestMixin", + "GmpDeleteOverrideTestMixin", + "GmpGetOverrideTestMixin", + "GmpGetOverridesTestMixin", + "GmpModifyOverrideTestMixin", +) diff --git a/tests/protocols/gmpv208/entities/overrides/test_clone_override.py b/tests/protocols/gmpv224/entities/overrides/test_clone_override.py similarity index 88% rename from tests/protocols/gmpv208/entities/overrides/test_clone_override.py rename to tests/protocols/gmpv224/entities/overrides/test_clone_override.py index 02e44c00b..f11f11be9 100644 --- a/tests/protocols/gmpv208/entities/overrides/test_clone_override.py +++ b/tests/protocols/gmpv224/entities/overrides/test_clone_override.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_override("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/overrides/test_create_override.py b/tests/protocols/gmpv224/entities/overrides/test_create_override.py index 8d94d0847..0f53a5932 100644 --- a/tests/protocols/gmpv224/entities/overrides/test_create_override.py +++ b/tests/protocols/gmpv224/entities/overrides/test_create_override.py @@ -6,7 +6,6 @@ from decimal import Decimal from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv224 import SeverityLevel class GmpCreateOverrideTestMixin: @@ -14,10 +13,10 @@ def test_create_override(self): self.gmp.create_override("foo", nvt_oid="oid1") self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) def test_create_override_missing_text(self): @@ -38,105 +37,105 @@ def test_create_override_with_hosts(self): self.gmp.create_override("foo", nvt_oid="oid1", hosts=[]) self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", hosts=["h1", "h2"]) self.connection.send.has_been_called_with( - "" - "foo" - '' - "h1,h2" - "" + b"" + b"foo" + b'' + b"h1,h2" + b"" ) def test_create_override_with_port(self): self.gmp.create_override("foo", nvt_oid="oid1", port="666/udp") self.connection.send.has_been_called_with( - "" - "foo" - '' - "666/udp" - "" + b"" + b"foo" + b'' + b"666/udp" + b"" ) def test_create_override_with_result_id(self): self.gmp.create_override("foo", nvt_oid="oid1", result_id="r1") self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" + b"" + b"foo" + b'' + b'' + b"" ) def test_create_override_with_task_id(self): self.gmp.create_override("foo", nvt_oid="oid1", task_id="t1") self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" + b"" + b"foo" + b'' + b'' + b"" ) def test_create_override_with_severity(self): self.gmp.create_override("foo", nvt_oid="oid1", severity="5.5") self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", severity=5.5) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", severity=Decimal(5.5)) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) def test_create_override_with_new_severity(self): self.gmp.create_override("foo", nvt_oid="oid1", new_severity="5.5") self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", new_severity=5.5) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) self.gmp.create_override( @@ -144,66 +143,42 @@ def test_create_override_with_new_severity(self): ) self.connection.send.has_been_called_with( - "" - "foo" - '' - "5.5" - "" - ) - - def test_create_override_with_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" - ) - - def test_create_override_with_new_threat(self): - self.gmp.create_override( - "foo", nvt_oid="oid1", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"5.5" + b"" ) def test_create_override_with_days_active(self): self.gmp.create_override("foo", nvt_oid="oid1", days_active=0) self.connection.send.has_been_called_with( - "" - "foo" - '' - "0" - "" + b"" + b"foo" + b'' + b"0" + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", days_active=-1) self.connection.send.has_been_called_with( - "" - "foo" - '' - "-1" - "" + b"" + b"foo" + b'' + b"-1" + b"" ) self.gmp.create_override("foo", nvt_oid="oid1", days_active=3600) self.connection.send.has_been_called_with( - "" - "foo" - '' - "3600" - "" + b"" + b"foo" + b'' + b"3600" + b"" ) def test_create_override_with_invalid_port(self): diff --git a/tests/protocols/gmpv208/entities/overrides/test_delete_override.py b/tests/protocols/gmpv224/entities/overrides/test_delete_override.py similarity index 83% rename from tests/protocols/gmpv208/entities/overrides/test_delete_override.py rename to tests/protocols/gmpv224/entities/overrides/test_delete_override.py index bbbd37ac8..4582c7457 100644 --- a/tests/protocols/gmpv208/entities/overrides/test_delete_override.py +++ b/tests/protocols/gmpv224/entities/overrides/test_delete_override.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_override("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_override("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/overrides/test_get_override.py b/tests/protocols/gmpv224/entities/overrides/test_get_override.py similarity index 84% rename from tests/protocols/gmpv208/entities/overrides/test_get_override.py rename to tests/protocols/gmpv224/entities/overrides/test_get_override.py index 898c54515..366cec692 100644 --- a/tests/protocols/gmpv208/entities/overrides/test_get_override.py +++ b/tests/protocols/gmpv224/entities/overrides/test_get_override.py @@ -11,13 +11,13 @@ def test_get_override(self): self.gmp.get_override("o1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_override(override_id="o1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_override_missing_override_id(self): diff --git a/tests/protocols/gmpv208/entities/overrides/test_get_overrides.py b/tests/protocols/gmpv224/entities/overrides/test_get_overrides.py similarity index 66% rename from tests/protocols/gmpv208/entities/overrides/test_get_overrides.py rename to tests/protocols/gmpv224/entities/overrides/test_get_overrides.py index 9262c9956..20f8d6525 100644 --- a/tests/protocols/gmpv208/entities/overrides/test_get_overrides.py +++ b/tests/protocols/gmpv224/entities/overrides/test_get_overrides.py @@ -8,40 +8,44 @@ class GmpGetOverridesTestMixin: def test_get_overrides(self): self.gmp.get_overrides() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_overrides_with_filter_string(self): self.gmp.get_overrides(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_overrides_with_filter_id(self): self.gmp.get_overrides(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_overrides_with_details(self): self.gmp.get_overrides(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_overrides(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_overrides_with_result(self): self.gmp.get_overrides(result=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_overrides(result=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) diff --git a/tests/protocols/gmpv224/entities/overrides/test_modify_override.py b/tests/protocols/gmpv224/entities/overrides/test_modify_override.py index 14ecce9ef..b231158e3 100644 --- a/tests/protocols/gmpv224/entities/overrides/test_modify_override.py +++ b/tests/protocols/gmpv224/entities/overrides/test_modify_override.py @@ -6,7 +6,6 @@ from decimal import Decimal from gvm.errors import InvalidArgument, RequiredArgument -from gvm.protocols.gmpv224 import SeverityLevel class GmpModifyOverrideTestMixin: @@ -14,9 +13,9 @@ def test_modify_override(self): self.gmp.modify_override(override_id="o1", text="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_override_missing_override_id(self): @@ -43,48 +42,48 @@ def test_modify_override_with_days_active(self): self.gmp.modify_override(override_id="o1", text="foo", days_active=0) self.connection.send.has_been_called_with( - '' - "foo" - "0" - "" + b'' + b"foo" + b"0" + b"" ) self.gmp.modify_override(override_id="o1", text="foo", days_active=-1) self.connection.send.has_been_called_with( - '' - "foo" - "-1" - "" + b'' + b"foo" + b"-1" + b"" ) self.gmp.modify_override(override_id="o1", text="foo", days_active=600) self.connection.send.has_been_called_with( - '' - "foo" - "600" - "" + b'' + b"foo" + b"600" + b"" ) def test_modify_override_with_port(self): self.gmp.modify_override(override_id="o1", text="foo", port="123/udp") self.connection.send.has_been_called_with( - '' - "foo" - "123/udp" - "" + b'' + b"foo" + b"123/udp" + b"" ) def test_modify_override_with_hosts(self): self.gmp.modify_override(override_id="o1", text="foo", hosts=["foo"]) self.connection.send.has_been_called_with( - '' - "foo" - "foo" - "" + b'' + b"foo" + b"foo" + b"" ) self.gmp.modify_override( @@ -92,49 +91,49 @@ def test_modify_override_with_hosts(self): ) self.connection.send.has_been_called_with( - '' - "foo" - "foo,bar" - "" + b'' + b"foo" + b"foo,bar" + b"" ) def test_modify_override_with_result_id(self): self.gmp.modify_override(override_id="o1", text="foo", result_id="r1") self.connection.send.has_been_called_with( - '' - "foo" - '' - "" + b'' + b"foo" + b'' + b"" ) def test_modify_override_with_task_id(self): self.gmp.modify_override(override_id="o1", text="foo", task_id="r1") self.connection.send.has_been_called_with( - '' - "foo" - '' - "" + b'' + b"foo" + b'' + b"" ) def test_modify_override_with_severity(self): self.gmp.modify_override(override_id="o1", text="foo", severity="5.5") self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_override(override_id="o1", text="foo", severity=5.5) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_override( @@ -142,10 +141,10 @@ def test_modify_override_with_severity(self): ) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) def test_modify_override_with_new_severity(self): @@ -154,19 +153,19 @@ def test_modify_override_with_new_severity(self): ) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_override(override_id="o1", text="foo", new_severity=5.5) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" + b'' + b"foo" + b"5.5" + b"" ) self.gmp.modify_override( @@ -174,32 +173,10 @@ def test_modify_override_with_new_severity(self): ) self.connection.send.has_been_called_with( - '' - "foo" - "5.5" - "" - ) - - def test_modify_override_with_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "" - ) - - def test_modify_override_with_new_threat(self): - self.gmp.modify_override( - override_id="o1", text="foo", new_threat=SeverityLevel.HIGH - ) - - self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"5.5" + b"" ) def test_modify_override_with_invalid_port(self): diff --git a/tests/protocols/gmpv208/entities/permissions/__init__.py b/tests/protocols/gmpv224/entities/permissions/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/permissions/__init__.py rename to tests/protocols/gmpv224/entities/permissions/__init__.py diff --git a/tests/protocols/gmpv208/entities/permissions/test_clone_permission.py b/tests/protocols/gmpv224/entities/permissions/test_clone_permission.py similarity index 88% rename from tests/protocols/gmpv208/entities/permissions/test_clone_permission.py rename to tests/protocols/gmpv224/entities/permissions/test_clone_permission.py index 26f1a815c..2c2149338 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_clone_permission.py +++ b/tests/protocols/gmpv224/entities/permissions/test_clone_permission.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_permission("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/permissions/test_create_permission.py b/tests/protocols/gmpv224/entities/permissions/test_create_permission.py similarity index 70% rename from tests/protocols/gmpv208/entities/permissions/test_create_permission.py rename to tests/protocols/gmpv224/entities/permissions/test_create_permission.py index dbcb1c86c..bdf7b5270 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_create_permission.py +++ b/tests/protocols/gmpv224/entities/permissions/test_create_permission.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import EntityType, PermissionSubjectType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import EntityType, PermissionSubjectType class GmpCreatePermissionTestMixin: @@ -14,12 +14,12 @@ def test_create_permission(self): ) self.connection.send.has_been_called_with( - "" - "foo" - '' - "user" - "" - "" + b"" + b"foo" + b'' + b"user" + b"" + b"" ) def test_create_permission_missing_name(self): @@ -49,17 +49,17 @@ def test_create_permission_missing_subject_id(self): ) def test_create_permission_invalid_subject_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(ValueError): self.gmp.create_permission( "create_task", subject_id="u1", subject_type="" ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(ValueError): self.gmp.create_permission( "create_task", subject_id="u1", subject_type=None ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_permission( "create_task", subject_id="u1", subject_type="foo" ) @@ -73,13 +73,13 @@ def test_create_permission_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "create_task" - '' - "user" - "" - "foo" - "" + b"" + b"create_task" + b'' + b"user" + b"" + b"foo" + b"" ) def test_create_permission_missing_resource_id(self): @@ -101,7 +101,7 @@ def test_create_permission_missing_resource_type(self): ) def test_create_permission_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_permission( "create_task", subject_id="u1", @@ -120,15 +120,15 @@ def test_create_permission_with_resource(self): ) self.connection.send.has_been_called_with( - "" - "create_task" - '' - "user" - "" - '' - "task" - "" - "" + b"" + b"create_task" + b'' + b"user" + b"" + b'' + b"task" + b"" + b"" ) def test_create_permission_with_resource_type_audit(self): @@ -141,15 +141,15 @@ def test_create_permission_with_resource_type_audit(self): ) self.connection.send.has_been_called_with( - "" - "create_task" - '' - "user" - "" - '' - "task" - "" - "" + b"" + b"create_task" + b'' + b"user" + b"" + b'' + b"task" + b"" + b"" ) def test_create_permission_with_resource_type_policy(self): @@ -162,13 +162,13 @@ def test_create_permission_with_resource_type_policy(self): ) self.connection.send.has_been_called_with( - "" - "create_task" - '' - "user" - "" - '' - "config" - "" - "" + b"" + b"create_task" + b'' + b"user" + b"" + b'' + b"config" + b"" + b"" ) diff --git a/tests/protocols/gmpv208/entities/permissions/test_delete_permission.py b/tests/protocols/gmpv224/entities/permissions/test_delete_permission.py similarity index 82% rename from tests/protocols/gmpv208/entities/permissions/test_delete_permission.py rename to tests/protocols/gmpv224/entities/permissions/test_delete_permission.py index e29963aa0..06a75995d 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_delete_permission.py +++ b/tests/protocols/gmpv224/entities/permissions/test_delete_permission.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_permission("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_permission("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/permissions/test_get_permission.py b/tests/protocols/gmpv224/entities/permissions/test_get_permission.py similarity index 86% rename from tests/protocols/gmpv208/entities/permissions/test_get_permission.py rename to tests/protocols/gmpv224/entities/permissions/test_get_permission.py index 8cc906202..06c22ac80 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_get_permission.py +++ b/tests/protocols/gmpv224/entities/permissions/test_get_permission.py @@ -11,13 +11,13 @@ def test_get_permission(self): self.gmp.get_permission("p1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_permission(permission_id="p1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_permission_missing_permission_id(self): diff --git a/tests/protocols/gmpv208/entities/permissions/test_get_permissions.py b/tests/protocols/gmpv224/entities/permissions/test_get_permissions.py similarity index 75% rename from tests/protocols/gmpv208/entities/permissions/test_get_permissions.py rename to tests/protocols/gmpv224/entities/permissions/test_get_permissions.py index 4f3f47505..0b18a94f5 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_get_permissions.py +++ b/tests/protocols/gmpv224/entities/permissions/test_get_permissions.py @@ -8,31 +8,31 @@ class GmpGetPermissionsTestMixin: def test_get_permissions(self): self.gmp.get_permissions() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_permissions_with_filter_string(self): self.gmp.get_permissions(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_permissions_with_filter_id(self): self.gmp.get_permissions(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_permissions_with_trash(self): self.gmp.get_permissions(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_permissions(trash=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/permissions/test_modify_permission.py b/tests/protocols/gmpv224/entities/permissions/test_modify_permission.py similarity index 74% rename from tests/protocols/gmpv208/entities/permissions/test_modify_permission.py rename to tests/protocols/gmpv224/entities/permissions/test_modify_permission.py index 116257e82..3b554153f 100644 --- a/tests/protocols/gmpv208/entities/permissions/test_modify_permission.py +++ b/tests/protocols/gmpv224/entities/permissions/test_modify_permission.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import EntityType, PermissionSubjectType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import EntityType, PermissionSubjectType class GmpModifyPermissionTestMixin: @@ -12,7 +12,7 @@ def test_modify_permission(self): self.gmp.modify_permission(permission_id="p1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_permission_missing_permission_id(self): @@ -29,9 +29,9 @@ def test_modify_permission_with_comment(self): self.gmp.modify_permission(permission_id="p1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_permission_with_resource_id_and_type(self): @@ -40,11 +40,11 @@ def test_modify_permission_with_resource_id_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "task" - "" - "" + b'' + b'' + b"task" + b"" + b"" ) def test_modify_permission_with_resource_id_and_type_audit(self): @@ -53,11 +53,11 @@ def test_modify_permission_with_resource_id_and_type_audit(self): ) self.connection.send.has_been_called_with( - '' - '' - "task" - "" - "" + b'' + b'' + b"task" + b"" + b"" ) def test_modify_permission_with_resource_id_and_type_policy(self): @@ -68,11 +68,11 @@ def test_modify_permission_with_resource_id_and_type_policy(self): ) self.connection.send.has_been_called_with( - '' - '' - "config" - "" - "" + b'' + b'' + b"config" + b"" + b"" ) def test_modify_permission_with_missing_resource_id(self): @@ -110,7 +110,7 @@ def test_modify_permission_with_missing_resource_type(self): ) def test_modify_permission_with_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_permission( permission_id="p1", resource_id="r1", resource_type="blah" ) @@ -123,11 +123,11 @@ def test_modify_permission_with_subject_id_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "role" - "" - "" + b'' + b'' + b"role" + b"" + b"" ) self.gmp.modify_permission( @@ -137,11 +137,11 @@ def test_modify_permission_with_subject_id_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "user" - "" - "" + b'' + b'' + b"user" + b"" + b"" ) self.gmp.modify_permission( @@ -151,11 +151,11 @@ def test_modify_permission_with_subject_id_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "group" - "" - "" + b'' + b'' + b"group" + b"" + b"" ) def test_modify_permission_missing_subject_id(self): @@ -179,17 +179,17 @@ def test_modify_permission_missing_subject_id(self): ) def test_modify_permission_invalid_subject_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_permission( permission_id="p1", subject_id="s1", subject_type="foo" ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.modify_permission( permission_id="p1", subject_id="s1", subject_type="" ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.modify_permission( permission_id="p1", subject_id="s1", subject_type=None ) @@ -198,7 +198,7 @@ def test_modify_permission_with_name(self): self.gmp.modify_permission(permission_id="p1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) diff --git a/tests/protocols/gmpv208/entities/policies/__init__.py b/tests/protocols/gmpv224/entities/policies/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/policies/__init__.py rename to tests/protocols/gmpv224/entities/policies/__init__.py diff --git a/tests/protocols/gmpv208/entities/policies/test_clone_policy.py b/tests/protocols/gmpv224/entities/policies/test_clone_policy.py similarity index 89% rename from tests/protocols/gmpv208/entities/policies/test_clone_policy.py rename to tests/protocols/gmpv224/entities/policies/test_clone_policy.py index 22c212d4b..f2e5670a4 100644 --- a/tests/protocols/gmpv208/entities/policies/test_clone_policy.py +++ b/tests/protocols/gmpv224/entities/policies/test_clone_policy.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_policy("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_create_policy.py b/tests/protocols/gmpv224/entities/policies/test_create_policy.py similarity index 64% rename from tests/protocols/gmpv208/entities/policies/test_create_policy.py rename to tests/protocols/gmpv224/entities/policies/test_create_policy.py index 2167d930f..8fc8bbe2c 100644 --- a/tests/protocols/gmpv208/entities/policies/test_create_policy.py +++ b/tests/protocols/gmpv224/entities/policies/test_create_policy.py @@ -11,23 +11,23 @@ def test_create_policy(self): self.gmp.create_policy("foo") self.connection.send.has_been_called_with( - "" - "085569ce-73ed-11df-83c3-002264764cea" - "foo" - "policy" - "" + b"" + b"085569ce-73ed-11df-83c3-002264764cea" + b"foo" + b"policy" + b"" ) def test_create_with_policy_id_and_comment(self): self.gmp.create_policy("foo", policy_id="p1", comment="foo") self.connection.send.has_been_called_with( - "" - "foo" - "p1" - "foo" - "policy" - "" + b"" + b"foo" + b"p1" + b"foo" + b"policy" + b"" ) def test_missing_name(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_delete_policy.py b/tests/protocols/gmpv224/entities/policies/test_delete_policy.py similarity index 84% rename from tests/protocols/gmpv208/entities/policies/test_delete_policy.py rename to tests/protocols/gmpv224/entities/policies/test_delete_policy.py index f6eb2ec79..a5e4e9bda 100644 --- a/tests/protocols/gmpv208/entities/policies/test_delete_policy.py +++ b/tests/protocols/gmpv224/entities/policies/test_delete_policy.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_policy("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_policy("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_config_id(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_get_policies.py b/tests/protocols/gmpv224/entities/policies/test_get_policies.py similarity index 72% rename from tests/protocols/gmpv208/entities/policies/test_get_policies.py rename to tests/protocols/gmpv224/entities/policies/test_get_policies.py index d0b34e306..9e274c5a6 100644 --- a/tests/protocols/gmpv208/entities/policies/test_get_policies.py +++ b/tests/protocols/gmpv224/entities/policies/test_get_policies.py @@ -9,82 +9,82 @@ def test_get_policies_simple(self): self.gmp.get_policies() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_filter_string(self): self.gmp.get_policies(filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_filter_id(self): self.gmp.get_policies(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_from_trash(self): self.gmp.get_policies(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_details(self): self.gmp.get_policies(details=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_without_details(self): self.gmp.get_policies(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_families(self): self.gmp.get_policies(families=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_without_families(self): self.gmp.get_policies(families=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_preferences(self): self.gmp.get_policies(preferences=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_without_preferences(self): self.gmp.get_policies(preferences=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_with_audits(self): self.gmp.get_policies(audits=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policies_without_audits(self): self.gmp.get_policies(audits=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/policies/test_get_policy.py b/tests/protocols/gmpv224/entities/policies/test_get_policy.py similarity index 78% rename from tests/protocols/gmpv208/entities/policies/test_get_policy.py rename to tests/protocols/gmpv224/entities/policies/test_get_policy.py index c8ed764ee..9f786f41e 100644 --- a/tests/protocols/gmpv208/entities/policies/test_get_policy.py +++ b/tests/protocols/gmpv224/entities/policies/test_get_policy.py @@ -11,15 +11,15 @@ def test_get_policy(self): self.gmp.get_policy("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_policy_with_audits(self): self.gmp.get_policy("a1", audits=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_fail_without_policy_id(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_import_policy.py b/tests/protocols/gmpv224/entities/policies/test_import_policy.py similarity index 90% rename from tests/protocols/gmpv208/entities/policies/test_import_policy.py rename to tests/protocols/gmpv224/entities/policies/test_import_policy.py index fe30eebcb..d185eee03 100644 --- a/tests/protocols/gmpv208/entities/policies/test_import_policy.py +++ b/tests/protocols/gmpv224/entities/policies/test_import_policy.py @@ -22,7 +22,9 @@ def test_import_policy(self): self.gmp.import_policy(self.POLICY_XML_STRING) self.connection.send.has_been_called_with( - "" f"{self.POLICY_XML_STRING}" "" + f"{self.POLICY_XML_STRING}".encode( + "utf-8" + ) ) def test_import_missing_policy_xml(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_comment.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_comment.py similarity index 74% rename from tests/protocols/gmpv208/entities/policies/test_modify_policy_set_comment.py rename to tests/protocols/gmpv224/entities/policies/test_modify_policy_set_comment.py index a0ba2a1fe..a82772df4 100644 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_comment.py +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_comment.py @@ -11,25 +11,25 @@ def test_modify_policy_set_comment(self): self.gmp.modify_policy_set_comment("c1") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) self.gmp.modify_policy_set_comment("c1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_policy_set_comment("c1", comment=None) self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) def test_modify_policy_set_comment_missing_policy_id(self): diff --git a/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_family_selection.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_family_selection.py new file mode 100644 index 000000000..c9fe6110a --- /dev/null +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_family_selection.py @@ -0,0 +1,192 @@ +# SPDX-FileCopyrightText: 2020-2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later +# + +from gvm.errors import RequiredArgument + + +class GmpModifyPolicySetFamilySelectionTestMixin: + def test_modify_policy_set_family_selection(self): + self.gmp.modify_policy_set_family_selection( + policy_id="c1", families=[("foo", True, True)] + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" + ) + + self.gmp.modify_policy_set_family_selection( + policy_id="c1", families=(("foo", True, True), ("bar", True, True)) + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"bar" + b"1" + b"1" + b"" + b"" + b"" + ) + + self.gmp.modify_policy_set_family_selection( + policy_id="c1", + families=[("foo", True, False), ("bar", False, True)], + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"0" + b"1" + b"" + b"" + b"bar" + b"1" + b"0" + b"" + b"" + b"" + ) + + def test_modify_policy_set_family_selection_missing_config_id(self): + with self.assertRaises(RequiredArgument): + self.gmp.modify_policy_set_family_selection( + policy_id=None, families=[("foo", True, True)] + ) + + with self.assertRaises(RequiredArgument): + self.gmp.modify_policy_set_family_selection( + policy_id="", families=[("foo", True, True)] + ) + + with self.assertRaises(RequiredArgument): + self.gmp.modify_policy_set_family_selection( + "", [("foo", True, True)] + ) + + def test_modify_policy_set_family_selection_invalid_families(self): + with self.assertRaises(RequiredArgument): + self.gmp.modify_policy_set_family_selection( + policy_id="c1", families=None + ) + + def test_modify_policy_set_family_selection_with_auto_add_new_families( + self, + ): + self.gmp.modify_policy_set_family_selection( + policy_id="c1", + families=[("foo", True, True)], + auto_add_new_families=True, + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" + ) + + self.gmp.modify_policy_set_family_selection( + policy_id="c1", + families=[("foo", True, True)], + auto_add_new_families=False, + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"0" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" + ) + + def test_modify_policy_set_family_selection_with_auto_add_new_nvts(self): + self.gmp.modify_policy_set_family_selection( + policy_id="c1", families=[("foo", True, True)] + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" + ) + + self.gmp.modify_policy_set_family_selection( + policy_id="c1", families=[("foo", False, True)] + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"" + ) + + self.gmp.modify_policy_set_family_selection( + policy_id="c1", + families=[("foo", False, True), ("bar", True, False)], + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"bar" + b"0" + b"1" + b"" + b"" + b"" + ) diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_name.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_name.py similarity index 91% rename from tests/protocols/gmpv208/entities/policies/test_modify_policy_set_name.py rename to tests/protocols/gmpv224/entities/policies/test_modify_policy_set_name.py index ccf7c1d47..0c5d8b2d7 100644 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_name.py +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_name.py @@ -11,9 +11,9 @@ def test_modify_policy_set_name(self): self.gmp.modify_policy_set_name("c1", "foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_policy_set_name_missing_config_id(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_preference.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_preference.py similarity index 79% rename from tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_preference.py rename to tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_preference.py index 00d1c1c15..7cacf476d 100644 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_preference.py +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_preference.py @@ -13,23 +13,23 @@ def test_modify_policy_set_nvt_pref(self): ) self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" + b'' + b"" + b'' + b"foo" + b"" + b"" ) self.gmp.modify_policy_set_nvt_preference("c1", "foo", "o1") self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" + b'' + b"" + b'' + b"foo" + b"" + b"" ) def test_modify_policy_set_nvt_pref_with_value(self): @@ -38,13 +38,13 @@ def test_modify_policy_set_nvt_pref_with_value(self): ) self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "YmFy" - "" - "" + b'' + b"" + b'' + b"foo" + b"YmFy" + b"" + b"" ) def test_modify_policy_set_nvt_pref_missing_nvt_oid(self): diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_selection.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_selection.py similarity index 61% rename from tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_selection.py rename to tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_selection.py index 4706d1f1d..d8192d9e3 100644 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_nvt_selection.py +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_nvt_selection.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument +from gvm.errors import RequiredArgument class GmpModifyPolicySetNvtSelectionTestMixin: @@ -13,12 +13,12 @@ def test_modify_policy_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" + b'' + b"" + b"foo" + b'' + b"" + b"" ) self.gmp.modify_policy_set_nvt_selection( @@ -26,36 +26,36 @@ def test_modify_policy_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" + b'' + b"" + b"foo" + b'' + b'' + b"" + b"" ) self.gmp.modify_policy_set_nvt_selection("c1", "foo", ["o1"]) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" + b'' + b"" + b"foo" + b'' + b"" + b"" ) self.gmp.modify_policy_set_nvt_selection("c1", "foo", ("o1", "o2")) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" + b'' + b"" + b"foo" + b'' + b'' + b"" + b"" ) self.gmp.modify_policy_set_nvt_selection( @@ -63,11 +63,11 @@ def test_modify_policy_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_policy_set_nvt_selection_missing_config_id(self): @@ -99,15 +99,7 @@ def test_modify_policy_set_nvt_selection_missing_family(self): self.gmp.modify_policy_set_nvt_selection("c1", "", ["o1"]) def test_modify_policy_set_nvt_selection_invalid_nvt_oids(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(RequiredArgument): self.gmp.modify_policy_set_nvt_selection( policy_id="c1", family="foo", nvt_oids=None ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_nvt_selection( - policy_id="c1", family="foo", nvt_oids="" - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_policy_set_nvt_selection("c1", "foo", "") diff --git a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_scanner_preference.py b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_scanner_preference.py similarity index 76% rename from tests/protocols/gmpv208/entities/policies/test_modify_policy_set_scanner_preference.py rename to tests/protocols/gmpv224/entities/policies/test_modify_policy_set_scanner_preference.py index 75fb1c4b4..a00fb1949 100644 --- a/tests/protocols/gmpv208/entities/policies/test_modify_policy_set_scanner_preference.py +++ b/tests/protocols/gmpv224/entities/policies/test_modify_policy_set_scanner_preference.py @@ -13,33 +13,33 @@ def test_modify_policy_set_scanner_pref(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) self.gmp.modify_policy_set_scanner_preference("c1", "foo") self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_policy_set_scanner_pref_with_value(self): self.gmp.modify_policy_set_scanner_preference("c1", "foo", value="bar") self.connection.send.has_been_called_with( - '' - "" - "foo" - "YmFy" - "" - "" + b'' + b"" + b"foo" + b"YmFy" + b"" + b"" ) def test_modify_policy_scanner_pref_missing_name(self): diff --git a/tests/protocols/gmpv208/entities/port_lists/__init__.py b/tests/protocols/gmpv224/entities/port_lists/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/port_lists/__init__.py rename to tests/protocols/gmpv224/entities/port_lists/__init__.py diff --git a/tests/protocols/gmpv208/entities/port_lists/test_clone_port_list.py b/tests/protocols/gmpv224/entities/port_lists/test_clone_port_list.py similarity index 88% rename from tests/protocols/gmpv208/entities/port_lists/test_clone_port_list.py rename to tests/protocols/gmpv224/entities/port_lists/test_clone_port_list.py index 56f485ab3..9f7ff84d2 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_clone_port_list.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_clone_port_list.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_port_list("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/port_lists/test_create_port_list.py b/tests/protocols/gmpv224/entities/port_lists/test_create_port_list.py similarity index 77% rename from tests/protocols/gmpv208/entities/port_lists/test_create_port_list.py rename to tests/protocols/gmpv224/entities/port_lists/test_create_port_list.py index b4927db17..47ffb1e7f 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_create_port_list.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_create_port_list.py @@ -25,10 +25,10 @@ def test_create_port_list(self): self.gmp.create_port_list(name="foo", port_range="T:1-1234") self.connection.send.has_been_called_with( - "" - "foo" - "T:1-1234" - "" + b"" + b"foo" + b"T:1-1234" + b"" ) def test_create_port_list_with_comment(self): @@ -37,9 +37,9 @@ def test_create_port_list_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "T:1-1234" - "lorem" - "" + b"" + b"foo" + b"T:1-1234" + b"lorem" + b"" ) diff --git a/tests/protocols/gmpv208/entities/port_lists/test_create_port_range.py b/tests/protocols/gmpv224/entities/port_lists/test_create_port_range.py similarity index 77% rename from tests/protocols/gmpv208/entities/port_lists/test_create_port_range.py rename to tests/protocols/gmpv224/entities/port_lists/test_create_port_range.py index 2bc43e954..c89d670d5 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_create_port_range.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_create_port_range.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208.entities.port_lists import PortRangeType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import PortRangeType class GmpCreatePortRangeTestMixin: @@ -71,7 +71,7 @@ def test_create_port_range_missing_port_range_type(self): ) def test_create_port_range_invalid_port_range_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_port_range( port_list_id="pl1", start=1, end=1234, port_range_type="blubb" ) @@ -85,12 +85,12 @@ def test_create_port_range(self): ) self.connection.send.has_been_called_with( - "" - '' - "1" - "1234" - "TCP" - "" + b"" + b'' + b"1" + b"1234" + b"TCP" + b"" ) self.gmp.create_port_range( @@ -101,12 +101,12 @@ def test_create_port_range(self): ) self.connection.send.has_been_called_with( - "" - '' - "1" - "1234" - "UDP" - "" + b"" + b'' + b"1" + b"1234" + b"UDP" + b"" ) self.gmp.create_port_range( @@ -117,12 +117,12 @@ def test_create_port_range(self): ) self.connection.send.has_been_called_with( - "" - '' - "1" - "1234" - "TCP" - "" + b"" + b'' + b"1" + b"1234" + b"TCP" + b"" ) def test_create_port_range_with_comment(self): @@ -135,11 +135,11 @@ def test_create_port_range_with_comment(self): ) self.connection.send.has_been_called_with( - "" - '' - "1" - "1234" - "TCP" - "lorem" - "" + b"" + b'' + b"1" + b"1234" + b"TCP" + b"lorem" + b"" ) diff --git a/tests/protocols/gmpv208/entities/port_lists/test_delete_port_list.py b/tests/protocols/gmpv224/entities/port_lists/test_delete_port_list.py similarity index 83% rename from tests/protocols/gmpv208/entities/port_lists/test_delete_port_list.py rename to tests/protocols/gmpv224/entities/port_lists/test_delete_port_list.py index b7f01cb9c..821f39ff9 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_delete_port_list.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_delete_port_list.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_port_list("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_port_list("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/port_lists/test_delete_port_range.py b/tests/protocols/gmpv224/entities/port_lists/test_delete_port_range.py similarity index 90% rename from tests/protocols/gmpv208/entities/port_lists/test_delete_port_range.py rename to tests/protocols/gmpv224/entities/port_lists/test_delete_port_range.py index b33fc77d3..4864b2182 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_delete_port_range.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_delete_port_range.py @@ -11,7 +11,7 @@ def test_delete(self): self.gmp.delete_port_range("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/port_lists/test_get_port_list.py b/tests/protocols/gmpv224/entities/port_lists/test_get_port_list.py similarity index 90% rename from tests/protocols/gmpv208/entities/port_lists/test_get_port_list.py rename to tests/protocols/gmpv224/entities/port_lists/test_get_port_list.py index 15922d899..f220bf0e9 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_get_port_list.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_get_port_list.py @@ -11,7 +11,7 @@ def test_get_port_list(self): self.gmp.get_port_list(port_list_id="port_list_id") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_port_list_missing_port_list_id(self): diff --git a/tests/protocols/gmpv208/entities/port_lists/test_get_port_lists.py b/tests/protocols/gmpv224/entities/port_lists/test_get_port_lists.py similarity index 68% rename from tests/protocols/gmpv208/entities/port_lists/test_get_port_lists.py rename to tests/protocols/gmpv224/entities/port_lists/test_get_port_lists.py index 472ed6394..2e20bd70a 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_get_port_lists.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_get_port_lists.py @@ -8,53 +8,57 @@ class GmpGetPortListsTestMixin: def test_get_port_lists(self): self.gmp.get_port_lists() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_port_lists_with_filter_string(self): self.gmp.get_port_lists(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_port_lists_with_filter_id(self): self.gmp.get_port_lists(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_port_lists_with_trash(self): self.gmp.get_port_lists(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_port_lists(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_port_lists_with_details(self): self.gmp.get_port_lists(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_port_lists(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_port_lists_with_targets(self): self.gmp.get_port_lists(targets=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_port_lists(targets=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/port_lists/test_modify_port_list.py b/tests/protocols/gmpv224/entities/port_lists/test_modify_port_list.py similarity index 77% rename from tests/protocols/gmpv208/entities/port_lists/test_modify_port_list.py rename to tests/protocols/gmpv224/entities/port_lists/test_modify_port_list.py index 1605a5059..aed318dc5 100644 --- a/tests/protocols/gmpv208/entities/port_lists/test_modify_port_list.py +++ b/tests/protocols/gmpv224/entities/port_lists/test_modify_port_list.py @@ -11,7 +11,7 @@ def test_modify_port_list(self): self.gmp.modify_port_list(port_list_id="p1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_port_list_missing_port_list_id(self): @@ -28,16 +28,16 @@ def test_modify_port_list_with_comment(self): self.gmp.modify_port_list(port_list_id="p1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_port_list_with_name(self): self.gmp.modify_port_list(port_list_id="p1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) diff --git a/tests/protocols/gmpv208/entities/report_formats/__init__.py b/tests/protocols/gmpv224/entities/report_formats/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/report_formats/__init__.py rename to tests/protocols/gmpv224/entities/report_formats/__init__.py diff --git a/tests/protocols/gmpv208/entities/report_formats/test_clone_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_clone_report_format.py similarity index 81% rename from tests/protocols/gmpv208/entities/report_formats/test_clone_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_clone_report_format.py index c32455bc8..dd66341b2 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_clone_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_clone_report_format.py @@ -4,7 +4,7 @@ # from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpCloneReportFormatTestMixin: @@ -12,7 +12,7 @@ def test_clone(self): self.gmp.clone_report_format("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): @@ -30,5 +30,5 @@ def test_clone_with_type(self): self.connection.send.has_been_called_with( "" f"{report_format_id}" - "" + "".encode("utf-8") ) diff --git a/tests/protocols/gmpv208/entities/report_formats/test_delete_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_delete_report_format.py similarity index 79% rename from tests/protocols/gmpv208/entities/report_formats/test_delete_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_delete_report_format.py index 4adaf6012..b6c660246 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_delete_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_delete_report_format.py @@ -4,7 +4,7 @@ # from gvm.errors import GvmError -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpDeleteReportFormatTestMixin: @@ -12,14 +12,14 @@ def test_delete(self): self.gmp.delete_report_format("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_report_format("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): @@ -35,5 +35,7 @@ def test_delete_with_type(self): report_format_id = ReportFormatType.from_string("svg").value self.connection.send.has_been_called_with( "' + f'report_format_id="{report_format_id}" ultimate="0"/>'.encode( + "utf-8" + ) ) diff --git a/tests/protocols/gmpv208/entities/report_formats/test_get_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_get_report_format.py similarity index 80% rename from tests/protocols/gmpv208/entities/report_formats/test_get_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_get_report_format.py index 11e5736c7..8ee8ed600 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_get_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_get_report_format.py @@ -4,7 +4,7 @@ # from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpGetReportFormatTestMixin: @@ -12,13 +12,13 @@ def test_get_report_format(self): self.gmp.get_report_format("rf1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report_format(report_format_id="rf1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_format_missing_report_format_id(self): @@ -33,12 +33,16 @@ def test_get_report_format_type(self): report_format_id = ReportFormatType.from_string("pdf").value self.connection.send.has_been_called_with( "' + f'report_format_id="{report_format_id}" details="1"/>'.encode( + "utf-8" + ) ) self.gmp.get_report_format(report_format_id=ReportFormatType.PDF) self.connection.send.has_been_called_with( "' + f'report_format_id="{report_format_id}" details="1"/>'.encode( + "utf-8" + ) ) diff --git a/tests/protocols/gmpv208/entities/report_formats/test_get_report_formats.py b/tests/protocols/gmpv224/entities/report_formats/test_get_report_formats.py similarity index 74% rename from tests/protocols/gmpv208/entities/report_formats/test_get_report_formats.py rename to tests/protocols/gmpv224/entities/report_formats/test_get_report_formats.py index 68296d166..0aed31698 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_get_report_formats.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_get_report_formats.py @@ -8,70 +8,70 @@ class GmpGetReportFormatsTestMixin: def test_get_report_formats(self): self.gmp.get_report_formats() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_report_formats_with_filter_string(self): self.gmp.get_report_formats(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_formats_with_filter_id(self): self.gmp.get_report_formats(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_formats_with_trash(self): self.gmp.get_report_formats(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report_formats(trash=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_formats_with_details(self): self.gmp.get_report_formats(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report_formats(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_formats_with_alerts(self): self.gmp.get_report_formats(alerts=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report_formats(alerts=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_formats_with_params(self): self.gmp.get_report_formats(params=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report_formats(params=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/report_formats/test_import_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_import_report_format.py similarity index 96% rename from tests/protocols/gmpv208/entities/report_formats/test_import_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_import_report_format.py index 38735959a..1fac28bab 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_import_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_import_report_format.py @@ -23,7 +23,9 @@ def test_import_report_format(self): self.connection.send.has_been_called_with( "" - f"{self.REPORT_FORMAT_XML_STRING}" + f"{self.REPORT_FORMAT_XML_STRING}".encode( + "utf-8" + ) ) def test_import_missing_report_format_xml(self): diff --git a/tests/protocols/gmpv208/entities/report_formats/test_modify_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_modify_report_format.py similarity index 64% rename from tests/protocols/gmpv208/entities/report_formats/test_modify_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_modify_report_format.py index 1703f5fec..28adfefe8 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_modify_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_modify_report_format.py @@ -4,7 +4,7 @@ # from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpModifyReportFormatTestMixin: @@ -12,7 +12,7 @@ def test_modify_report_format(self): self.gmp.modify_report_format(report_format_id="rf1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_report_format_missing_report_format_id(self): @@ -29,18 +29,18 @@ def test_modify_report_format_with_summary(self): self.gmp.modify_report_format(report_format_id="rf1", summary="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_report_format_with_name(self): self.gmp.modify_report_format(report_format_id="rf1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_report_format_with_name_and_type(self): @@ -51,35 +51,35 @@ def test_modify_report_format_with_name_and_type(self): report_format_id = ReportFormatType.from_string("xml").value self.connection.send.has_been_called_with( f'' - "foo" + "foo".encode("utf-8") ) def test_modify_report_format_with_active(self): self.gmp.modify_report_format(report_format_id="rf1", active=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_report_format(report_format_id="rf1", active=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_report_format_with_param_name(self): self.gmp.modify_report_format(report_format_id="rf1", param_name="foo") self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_report_format_with_param_name_and_value(self): @@ -88,12 +88,12 @@ def test_modify_report_format_with_param_name_and_value(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "bar" - "" - "" + b'' + b"" + b"foo" + b"bar" + b"" + b"" ) self.gmp.modify_report_format( @@ -101,10 +101,10 @@ def test_modify_report_format_with_param_name_and_value(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" - "" + b'' + b"" + b"foo" + b"" + b"" + b"" ) diff --git a/tests/protocols/gmpv208/entities/report_formats/test_verify_report_format.py b/tests/protocols/gmpv224/entities/report_formats/test_verify_report_format.py similarity index 81% rename from tests/protocols/gmpv208/entities/report_formats/test_verify_report_format.py rename to tests/protocols/gmpv224/entities/report_formats/test_verify_report_format.py index 4b9ec6e47..76c2e91a5 100644 --- a/tests/protocols/gmpv208/entities/report_formats/test_verify_report_format.py +++ b/tests/protocols/gmpv224/entities/report_formats/test_verify_report_format.py @@ -4,7 +4,7 @@ # from gvm.errors import GvmError -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpVerifyReportFormatTestMixin: @@ -12,7 +12,7 @@ def test_verify(self): self.gmp.verify_report_format("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): @@ -27,5 +27,7 @@ def test_verify_with_type(self): report_format_id = ReportFormatType.from_string("svg").value self.connection.send.has_been_called_with( - f'' + f''.encode( + "utf-8" + ) ) diff --git a/tests/protocols/gmpv208/entities/reports/__init__.py b/tests/protocols/gmpv224/entities/reports/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/reports/__init__.py rename to tests/protocols/gmpv224/entities/reports/__init__.py diff --git a/tests/protocols/gmpv208/entities/reports/test_delete_report.py b/tests/protocols/gmpv224/entities/reports/test_delete_report.py similarity index 91% rename from tests/protocols/gmpv208/entities/reports/test_delete_report.py rename to tests/protocols/gmpv224/entities/reports/test_delete_report.py index 48ae36994..e86cc4831 100644 --- a/tests/protocols/gmpv208/entities/reports/test_delete_report.py +++ b/tests/protocols/gmpv224/entities/reports/test_delete_report.py @@ -11,7 +11,7 @@ def test_delete(self): self.gmp.delete_report("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/reports/test_get_report.py b/tests/protocols/gmpv224/entities/reports/test_get_report.py similarity index 75% rename from tests/protocols/gmpv208/entities/reports/test_get_report.py rename to tests/protocols/gmpv224/entities/reports/test_get_report.py index 5248f2b07..3b9ed0419 100644 --- a/tests/protocols/gmpv208/entities/reports/test_get_report.py +++ b/tests/protocols/gmpv224/entities/reports/test_get_report.py @@ -4,7 +4,7 @@ # from gvm.errors import RequiredArgument -from gvm.protocols.gmpv208.entities.report_formats import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GmpGetReportTestMixin: @@ -19,21 +19,21 @@ def test_get_report_with_filter_string(self): self.gmp.get_report(report_id="r1", filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_with_filter_id(self): self.gmp.get_report(report_id="r1", filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_with_report_format_id(self): self.gmp.get_report(report_id="r1", report_format_id="bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_with_report_format_type(self): @@ -44,38 +44,38 @@ def test_get_report_with_report_format_type(self): self.connection.send.has_been_called_with( '' + f'"{report_format_id}" details="1"/>'.encode("utf-8") ) def test_get_report_with_delta_report_id(self): self.gmp.get_report(report_id="r1", delta_report_id="r2") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_with_ignore_pagination(self): self.gmp.get_report(report_id="r1", ignore_pagination=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report(report_id="r1", ignore_pagination=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_report_with_details(self): self.gmp.get_report(report_id="r1", details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_report(report_id="r1", details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/reports/test_get_reports.py b/tests/protocols/gmpv224/entities/reports/test_get_reports.py similarity index 71% rename from tests/protocols/gmpv208/entities/reports/test_get_reports.py rename to tests/protocols/gmpv224/entities/reports/test_get_reports.py index 0bdc64ff0..c59f52d03 100644 --- a/tests/protocols/gmpv208/entities/reports/test_get_reports.py +++ b/tests/protocols/gmpv224/entities/reports/test_get_reports.py @@ -8,56 +8,56 @@ class GmpGetReportsTestMixin: def test_get_reports(self): self.gmp.get_reports() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_reports_with_filter_string(self): self.gmp.get_reports(filter_string="name=foo", ignore_pagination=1) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_with_filter_id(self): self.gmp.get_reports(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_without_note_details(self): self.gmp.get_reports(note_details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_with_note_details(self): self.gmp.get_reports(note_details=True, ignore_pagination=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_without_override_details(self): self.gmp.get_reports(override_details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_with_override_details(self): self.gmp.get_reports(override_details=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_reports_with_details(self): self.gmp.get_reports(details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_reports_without_details(self): self.gmp.get_reports(details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/reports/test_import_report.py b/tests/protocols/gmpv224/entities/reports/test_import_report.py similarity index 89% rename from tests/protocols/gmpv208/entities/reports/test_import_report.py rename to tests/protocols/gmpv224/entities/reports/test_import_report.py index 85f561fe0..dc3450960 100644 --- a/tests/protocols/gmpv208/entities/reports/test_import_report.py +++ b/tests/protocols/gmpv224/entities/reports/test_import_report.py @@ -25,7 +25,7 @@ def test_import_report_with_task_id(self): "" f'' f"{self.REPORT_XML_STRING}" - "" + "".encode("utf-8") ) def test_import_report_missing_report(self): @@ -35,10 +35,6 @@ def test_import_report_missing_report(self): with self.assertRaises(RequiredArgument): self.gmp.import_report("", task_id=self.TASK_ID) - def test_import_report_missing_task(self): - with self.assertRaises(RequiredArgument): - self.gmp.import_report(self.REPORT_XML_STRING) - def test_import_report_invalid_xml(self): with self.assertRaises(InvalidArgument): self.gmp.import_report("Foo", task_id=self.TASK_ID) # not root tag @@ -58,7 +54,7 @@ def test_import_report_with_in_assets(self): f'' "0" f"{self.REPORT_XML_STRING}" - "" + "".encode("utf-8") ) self.gmp.import_report( @@ -70,5 +66,5 @@ def test_import_report_with_in_assets(self): f'' "1" f"{self.REPORT_XML_STRING}" - "" + "".encode("utf-8") ) diff --git a/tests/protocols/gmpv208/entities/results/__init__.py b/tests/protocols/gmpv224/entities/results/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/results/__init__.py rename to tests/protocols/gmpv224/entities/results/__init__.py diff --git a/tests/protocols/gmpv208/entities/results/test_get_result.py b/tests/protocols/gmpv224/entities/results/test_get_result.py similarity index 84% rename from tests/protocols/gmpv208/entities/results/test_get_result.py rename to tests/protocols/gmpv224/entities/results/test_get_result.py index 0061aa7c2..39db42f2a 100644 --- a/tests/protocols/gmpv208/entities/results/test_get_result.py +++ b/tests/protocols/gmpv224/entities/results/test_get_result.py @@ -11,13 +11,13 @@ def test_get_result(self): self.gmp.get_result("r1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_result(result_id="r1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_result_missing_result_id(self): diff --git a/tests/protocols/gmpv208/entities/results/test_get_results.py b/tests/protocols/gmpv224/entities/results/test_get_results.py similarity index 64% rename from tests/protocols/gmpv208/entities/results/test_get_results.py rename to tests/protocols/gmpv224/entities/results/test_get_results.py index f2ff9a6a9..a9ad07b9f 100644 --- a/tests/protocols/gmpv208/entities/results/test_get_results.py +++ b/tests/protocols/gmpv224/entities/results/test_get_results.py @@ -8,56 +8,60 @@ class GmpGetResultsTestMixin: def test_get_results(self): self.gmp.get_results() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_results_with_filter_string(self): self.gmp.get_results(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_results_with_filter_id(self): self.gmp.get_results(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_results_with_note_details(self): self.gmp.get_results(note_details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_results(note_details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_results_with_override_details(self): self.gmp.get_results(override_details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_results(override_details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_results_with_details(self): self.gmp.get_results(details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_results(details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_results_with_task_id(self): self.gmp.get_results(task_id="t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) diff --git a/tests/protocols/gmpv208/entities/roles/__init__.py b/tests/protocols/gmpv224/entities/roles/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/roles/__init__.py rename to tests/protocols/gmpv224/entities/roles/__init__.py diff --git a/tests/protocols/gmpv208/entities/roles/test_clone_role.py b/tests/protocols/gmpv224/entities/roles/test_clone_role.py similarity index 89% rename from tests/protocols/gmpv208/entities/roles/test_clone_role.py rename to tests/protocols/gmpv224/entities/roles/test_clone_role.py index 99f743263..2cc7913de 100644 --- a/tests/protocols/gmpv208/entities/roles/test_clone_role.py +++ b/tests/protocols/gmpv224/entities/roles/test_clone_role.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_role("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/roles/test_create_role.py b/tests/protocols/gmpv224/entities/roles/test_create_role.py similarity index 71% rename from tests/protocols/gmpv208/entities/roles/test_create_role.py rename to tests/protocols/gmpv224/entities/roles/test_create_role.py index 3b2cd6719..b89ce32a9 100644 --- a/tests/protocols/gmpv208/entities/roles/test_create_role.py +++ b/tests/protocols/gmpv224/entities/roles/test_create_role.py @@ -11,7 +11,7 @@ def test_create_role(self): self.gmp.create_role(name="foo") self.connection.send.has_been_called_with( - "foo" + b"foo" ) def test_missing_name(self): @@ -25,24 +25,24 @@ def test_create_role_with_comment(self): self.gmp.create_role(name="foo", comment="bar") self.connection.send.has_been_called_with( - "" - "foo" - "bar" - "" + b"" + b"foo" + b"bar" + b"" ) def test_create_role_with_users(self): self.gmp.create_role(name="foo", users=[]) self.connection.send.has_been_called_with( - "foo" + b"foo" ) self.gmp.create_role(name="foo", users=["u1", "u2"]) self.connection.send.has_been_called_with( - "" - "foo" - "u1,u2" - "" + b"" + b"foo" + b"u1,u2" + b"" ) diff --git a/tests/protocols/gmpv208/entities/roles/test_delete_role.py b/tests/protocols/gmpv224/entities/roles/test_delete_role.py similarity index 84% rename from tests/protocols/gmpv208/entities/roles/test_delete_role.py rename to tests/protocols/gmpv224/entities/roles/test_delete_role.py index 9e4ce4417..4cfc831d7 100644 --- a/tests/protocols/gmpv208/entities/roles/test_delete_role.py +++ b/tests/protocols/gmpv224/entities/roles/test_delete_role.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_role("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_role("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/roles/test_get_role.py b/tests/protocols/gmpv224/entities/roles/test_get_role.py similarity index 75% rename from tests/protocols/gmpv208/entities/roles/test_get_role.py rename to tests/protocols/gmpv224/entities/roles/test_get_role.py index 4670ea622..12da99df7 100644 --- a/tests/protocols/gmpv208/entities/roles/test_get_role.py +++ b/tests/protocols/gmpv224/entities/roles/test_get_role.py @@ -10,11 +10,11 @@ class GmpGetRoleTestMixin: def test_get_role(self): self.gmp.get_role("r1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_role(role_id="r1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_role_missing_role_id(self): with self.assertRaises(RequiredArgument): diff --git a/tests/protocols/gmpv208/entities/roles/test_get_roles.py b/tests/protocols/gmpv224/entities/roles/test_get_roles.py similarity index 62% rename from tests/protocols/gmpv208/entities/roles/test_get_roles.py rename to tests/protocols/gmpv224/entities/roles/test_get_roles.py index 5230db625..4cc123cb1 100644 --- a/tests/protocols/gmpv208/entities/roles/test_get_roles.py +++ b/tests/protocols/gmpv224/entities/roles/test_get_roles.py @@ -8,25 +8,25 @@ class GmpGetRolesTestMixin: def test_get_roles(self): self.gmp.get_roles() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_roles_with_filter_string(self): self.gmp.get_roles(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_roles_with_filter_id(self): self.gmp.get_roles(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_roles_with_trash(self): self.gmp.get_roles(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_roles(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/roles/test_modify_role.py b/tests/protocols/gmpv224/entities/roles/test_modify_role.py similarity index 68% rename from tests/protocols/gmpv208/entities/roles/test_modify_role.py rename to tests/protocols/gmpv224/entities/roles/test_modify_role.py index 85041dc39..75f6aa8b0 100644 --- a/tests/protocols/gmpv208/entities/roles/test_modify_role.py +++ b/tests/protocols/gmpv224/entities/roles/test_modify_role.py @@ -10,7 +10,9 @@ class GmpModifyRoleTestMixin: def test_modify_role(self): self.gmp.modify_role(role_id="r1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_modify_role_missing_role_id(self): with self.assertRaises(RequiredArgument): @@ -26,33 +28,35 @@ def test_modify_role_with_comment(self): self.gmp.modify_role(role_id="r1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_role_with_name(self): self.gmp.modify_role(role_id="r1", name="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_role_with_users(self): self.gmp.modify_role(role_id="r1", users=[]) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.modify_role(role_id="r1", users=["foo"]) self.connection.send.has_been_called_with( - 'foo' + b'foo' ) self.gmp.modify_role(role_id="r1", users=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - "foo,bar" - "" + b'' + b"foo,bar" + b"" ) diff --git a/tests/protocols/gmpv224/entities/scan_configs/__init__.py b/tests/protocols/gmpv224/entities/scan_configs/__init__.py index 7ad10437a..d264d5779 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/__init__.py +++ b/tests/protocols/gmpv224/entities/scan_configs/__init__.py @@ -13,7 +13,6 @@ ) from .test_get_scan_configs import GmpGetScanConfigsTestMixin from .test_import_scan_config import GmpImportScanConfigTestMixin -from .test_modify_scan_config import GmpModifyScanConfigTestMixin from .test_modify_scan_config_set_comment import ( GmpModifyScanConfigSetCommentTestMixin, ) @@ -42,7 +41,6 @@ "GmpGetScanConfigPreferencesTestMixin", "GmpGetScanConfigsTestMixin", "GmpImportScanConfigTestMixin", - "GmpModifyScanConfigTestMixin", "GmpModifyScanConfigSetCommentTestMixin", "GmpModifyScanConfigSetFamilySelectionTestMixin", "GmpModifyScanConfigSetNameTestMixin", diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_clone_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_clone_scan_config.py index 3ab56ab2e..e5e5aaf8d 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_clone_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_clone_scan_config.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_scan_config("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_create_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_create_scan_config.py index abdd60751..97213f78a 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_create_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_create_scan_config.py @@ -11,23 +11,23 @@ def test_create_scan_config(self): self.gmp.create_scan_config("a1", "foo") self.connection.send.has_been_called_with( - "" - "a1" - "foo" - "scan" - "" + b"" + b"a1" + b"foo" + b"scan" + b"" ) def test_create_scan_config_with_comment(self): self.gmp.create_scan_config("a1", "foo", comment="comment") self.connection.send.has_been_called_with( - "" - "comment" - "a1" - "foo" - "scan" - "" + b"" + b"comment" + b"a1" + b"foo" + b"scan" + b"" ) def test_create_scan_config_missing_scan_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_delete_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_delete_scan_config.py index d07a2c9cc..82c2ad665 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_delete_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_delete_scan_config.py @@ -11,14 +11,14 @@ def test_delete_scan_config(self): self.gmp.delete_scan_config("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_scan_config_ultimate(self): self.gmp.delete_scan_config("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_scan_config_missing_scan_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config.py index 86a0fcbd3..04ba46194 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config.py @@ -11,15 +11,15 @@ def test_get_scan_config(self): self.gmp.get_scan_config("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_with_tasks(self): self.gmp.get_scan_config("a1", tasks=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_fail_without_scan_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preference.py b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preference.py index 807bac826..cd53e6867 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preference.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preference.py @@ -11,7 +11,7 @@ def test_get_preference(self): self.gmp.get_scan_config_preference(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_preference_missing_name(self): @@ -28,12 +28,12 @@ def test_get_scan_config_preference_with_nvt_oid(self): self.gmp.get_scan_config_preference(name="foo", nvt_oid="oid") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_preference_with_config_id(self): self.gmp.get_scan_config_preference(name="foo", config_id="c1") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preferences.py b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preferences.py index 5fa8093f0..8834e394e 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preferences.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_config_preferences.py @@ -8,18 +8,18 @@ class GmpGetScanConfigPreferencesTestMixin: def test_get_scan_config_preferences(self): self.gmp.get_scan_config_preferences() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_scan_config_preferences_with_nvt_oid(self): self.gmp.get_scan_config_preferences(nvt_oid="oid") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_preferences_with_config_id(self): self.gmp.get_scan_config_preferences(config_id="c1") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_configs.py b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_configs.py index f11d5e874..aa434cbb7 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_configs.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_get_scan_configs.py @@ -9,82 +9,82 @@ def test_get_scan_configs_simple(self): self.gmp.get_scan_configs() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_filter_string(self): self.gmp.get_scan_configs(filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_filter_id(self): self.gmp.get_scan_configs(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_from_trash(self): self.gmp.get_scan_configs(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_details(self): self.gmp.get_scan_configs(details=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_without_details(self): self.gmp.get_scan_configs(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_families(self): self.gmp.get_scan_configs(families=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_without_families(self): self.gmp.get_scan_configs(families=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_preferences(self): self.gmp.get_scan_configs(preferences=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_without_preferences(self): self.gmp.get_scan_configs(preferences=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_with_tasks(self): self.gmp.get_scan_configs(tasks=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_configs_without_tasks(self): self.gmp.get_scan_configs(tasks=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_import_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_import_scan_config.py index 8873d368f..3e8352b67 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_import_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_import_scan_config.py @@ -22,7 +22,9 @@ def test_import_scan_config(self): self.gmp.import_scan_config(self.CONFIG_XML_STRING) self.connection.send.has_been_called_with( - "" f"{self.CONFIG_XML_STRING}" "" + f"{self.CONFIG_XML_STRING}".encode( + "utf-8" + ) ) def test_import_missing_scan_config_xml(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config.py index b3530a030..ac8e28769 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config.py @@ -38,9 +38,9 @@ def test_modify_scan_config_set_comment(self): self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scan_config_set_nvt_pref(self): @@ -56,12 +56,12 @@ def test_modify_scan_config_set_nvt_pref(self): self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" + b'' + b"" + b'' + b"foo" + b"" + b"" ) def test_modify_scan_config_set_scanner_pref(self): @@ -77,12 +77,12 @@ def test_modify_scan_config_set_scanner_pref(self): self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.connection.send.has_been_called_with( - '' - "" - "foo" - "YmFy" - "" - "" + b'' + b"" + b"foo" + b"YmFy" + b"" + b"" ) def test_modify_scan_config_set_nvt_selection(self): @@ -101,12 +101,12 @@ def test_modify_scan_config_set_nvt_selection(self): self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" + b'' + b"" + b"foo" + b'' + b"" + b"" ) def test_modify_scan_config_set_family_selection(self): @@ -124,14 +124,14 @@ def test_modify_scan_config_set_family_selection(self): self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" ) diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_comment.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_comment.py index 3fac21010..190a8bd38 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_comment.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_comment.py @@ -11,25 +11,25 @@ def test_modify_scan_config_set_comment(self): self.gmp.modify_scan_config_set_comment("c1") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) self.gmp.modify_scan_config_set_comment("c1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_scan_config_set_comment("c1", comment=None) self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) def test_modify_scan_config_set_comment_missing_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_family_selection.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_family_selection.py index 2b00eb4cc..f7e653676 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_family_selection.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_family_selection.py @@ -13,16 +13,16 @@ def test_modify_scan_config_set_family_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -30,21 +30,21 @@ def test_modify_scan_config_set_family_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "bar" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"bar" + b"1" + b"1" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -52,21 +52,21 @@ def test_modify_scan_config_set_family_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "bar" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"bar" + b"1" + b"1" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -75,21 +75,21 @@ def test_modify_scan_config_set_family_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "0" - "1" - "" - "" - "bar" - "1" - "0" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"0" + b"1" + b"" + b"" + b"bar" + b"1" + b"0" + b"" + b"" + b"" ) def test_modify_scan_config_set_family_selection_missing_config_id(self): @@ -132,16 +132,16 @@ def test_modify_scan_config_set_family_selection_with_auto_add_new_families( ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -151,16 +151,16 @@ def test_modify_scan_config_set_family_selection_with_auto_add_new_families( ) self.connection.send.has_been_called_with( - '' - "" - "0" - "" - "foo" - "1" - "1" - "" - "" - "" + b'' + b"" + b"0" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" ) def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( @@ -171,16 +171,16 @@ def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"1" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -188,16 +188,16 @@ def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"" ) self.gmp.modify_scan_config_set_family_selection( @@ -206,21 +206,21 @@ def test_modify_scan_config_set_family_selection_with_auto_add_new_nvts( ) self.connection.send.has_been_called_with( - '' - "" - "1" - "" - "foo" - "1" - "0" - "" - "" - "bar" - "0" - "1" - "" - "" - "" + b'' + b"" + b"1" + b"" + b"foo" + b"1" + b"0" + b"" + b"" + b"bar" + b"0" + b"1" + b"" + b"" + b"" ) with self.assertRaises(InvalidArgumentType): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_name.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_name.py index f4481e76f..1c0889d4b 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_name.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_name.py @@ -11,9 +11,9 @@ def test_modify_scan_config_set_name(self): self.gmp.modify_scan_config_set_name("c1", "foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scan_config_set_name_missing_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py index 59aba32b9..fd95095de 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_preference.py @@ -13,23 +13,23 @@ def test_modify_scan_config_set_nvt_pref(self): ) self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" + b'' + b"" + b'' + b"foo" + b"" + b"" ) self.gmp.modify_scan_config_set_nvt_preference("c1", "foo", "o1") self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "" - "" + b'' + b"" + b'' + b"foo" + b"" + b"" ) def test_modify_scan_config_set_nvt_pref_with_value(self): @@ -38,13 +38,13 @@ def test_modify_scan_config_set_nvt_pref_with_value(self): ) self.connection.send.has_been_called_with( - '' - "" - '' - "foo" - "YmFy" - "" - "" + b'' + b"" + b'' + b"foo" + b"YmFy" + b"" + b"" ) def test_modify_scan_config_set_nvt_pref_missing_nvt_oid(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py index aae8df6da..2a4e42ac9 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_nvt_selection.py @@ -13,12 +13,12 @@ def test_modify_scan_config_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" + b'' + b"" + b"foo" + b'' + b"" + b"" ) self.gmp.modify_scan_config_set_nvt_selection( @@ -26,36 +26,36 @@ def test_modify_scan_config_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" + b'' + b"" + b"foo" + b'' + b'' + b"" + b"" ) self.gmp.modify_scan_config_set_nvt_selection("c1", "foo", ["o1"]) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - "" - "" + b'' + b"" + b"foo" + b'' + b"" + b"" ) self.gmp.modify_scan_config_set_nvt_selection("c1", "foo", ("o1", "o2")) self.connection.send.has_been_called_with( - '' - "" - "foo" - '' - '' - "" - "" + b'' + b"" + b"foo" + b'' + b'' + b"" + b"" ) self.gmp.modify_scan_config_set_nvt_selection( @@ -63,11 +63,11 @@ def test_modify_scan_config_set_nvt_selection(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_scan_config_set_nvt_selection_missing_config_id(self): diff --git a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py index c43ab72d2..36003cb6e 100644 --- a/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py +++ b/tests/protocols/gmpv224/entities/scan_configs/test_modify_scan_config_set_scanner_preference.py @@ -13,21 +13,21 @@ def test_modify_scan_config_set_scanner_pref(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) self.gmp.modify_scan_config_set_scanner_preference("c1", "foo") self.connection.send.has_been_called_with( - '' - "" - "foo" - "" - "" + b'' + b"" + b"foo" + b"" + b"" ) def test_modify_scan_config_set_scanner_pref_with_value(self): @@ -36,12 +36,12 @@ def test_modify_scan_config_set_scanner_pref_with_value(self): ) self.connection.send.has_been_called_with( - '' - "" - "foo" - "YmFy" - "" - "" + b'' + b"" + b"foo" + b"YmFy" + b"" + b"" ) def test_modify_scan_config_scanner_pref_missing_name(self): diff --git a/tests/protocols/gmpv224/entities/scanners/__init__.py b/tests/protocols/gmpv224/entities/scanners/__init__.py index be250ae97..97e2d0313 100644 --- a/tests/protocols/gmpv224/entities/scanners/__init__.py +++ b/tests/protocols/gmpv224/entities/scanners/__init__.py @@ -3,7 +3,20 @@ # SPDX-License-Identifier: GPL-3.0-or-later # +from .test_clone_scanner import GmpCloneScannerTestMixin from .test_create_scanner import GmpCreateScannerTestMixin +from .test_delete_scanner import GmpDeleteScannerTestMixin +from .test_get_scanner import GmpGetScannerTestMixin +from .test_get_scanners import GmpGetScannersTestMixin from .test_modify_scanner import GmpModifyScannerTestMixin +from .test_verify_scanner import GmpVerifyScannerTestMixin -__all__ = ("GmpCreateScannerTestMixin", "GmpModifyScannerTestMixin") +__all__ = ( + "GmpCloneScannerTestMixin", + "GmpCreateScannerTestMixin", + "GmpDeleteScannerTestMixin", + "GmpGetScannerTestMixin", + "GmpGetScannersTestMixin", + "GmpModifyScannerTestMixin", + "GmpVerifyScannerTestMixin", +) diff --git a/tests/protocols/gmpv208/entities/scanners/test_clone_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_clone_scanner.py similarity index 88% rename from tests/protocols/gmpv208/entities/scanners/test_clone_scanner.py rename to tests/protocols/gmpv224/entities/scanners/test_clone_scanner.py index 006e67169..c48199428 100644 --- a/tests/protocols/gmpv208/entities/scanners/test_clone_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_clone_scanner.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_scanner("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/scanners/test_create_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_create_scanner.py index f7f383091..f965fe1ae 100644 --- a/tests/protocols/gmpv224/entities/scanners/test_create_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_create_scanner.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv224 import ScannerType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ScannerType class GmpCreateScannerTestMixin: @@ -18,13 +18,13 @@ def test_create_scanner(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "2" - '' - "" + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"" ) def test_create_scanner_missing_name(self): @@ -123,7 +123,7 @@ def test_create_scanner_missing_credential_id(self): ) def test_create_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_scanner( name="foo", host="localhost", @@ -141,7 +141,7 @@ def test_create_scanner_invalid_scanner_type(self): credential_id="c1", ) - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_scanner( name="foo", host="localhost", @@ -161,14 +161,14 @@ def test_create_scanner_with_ca_pub(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "2" - "foo" - '' - "" + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"foo" + b"" ) def test_create_scanner_with_comment(self): @@ -182,12 +182,12 @@ def test_create_scanner_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "localhost" - "1234" - "2" - '' - "bar" - "" + b"" + b"foo" + b"localhost" + b"1234" + b"2" + b'' + b"bar" + b"" ) diff --git a/tests/protocols/gmpv208/entities/scanners/test_delete_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_delete_scanner.py similarity index 83% rename from tests/protocols/gmpv208/entities/scanners/test_delete_scanner.py rename to tests/protocols/gmpv224/entities/scanners/test_delete_scanner.py index 953e7c0fc..0592fb7a0 100644 --- a/tests/protocols/gmpv208/entities/scanners/test_delete_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_delete_scanner.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_scanner("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_scanner("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/scanners/test_get_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_get_scanner.py similarity index 84% rename from tests/protocols/gmpv208/entities/scanners/test_get_scanner.py rename to tests/protocols/gmpv224/entities/scanners/test_get_scanner.py index e393e47b4..d31e9c39e 100644 --- a/tests/protocols/gmpv208/entities/scanners/test_get_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_get_scanner.py @@ -11,13 +11,13 @@ def test_get_scanner(self): self.gmp.get_scanner("s1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_scanner(scanner_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scanner_missing_scanner_id(self): diff --git a/tests/protocols/gmpv208/entities/scanners/test_get_scanners.py b/tests/protocols/gmpv224/entities/scanners/test_get_scanners.py similarity index 60% rename from tests/protocols/gmpv208/entities/scanners/test_get_scanners.py rename to tests/protocols/gmpv224/entities/scanners/test_get_scanners.py index cff604393..cc8912c90 100644 --- a/tests/protocols/gmpv208/entities/scanners/test_get_scanners.py +++ b/tests/protocols/gmpv224/entities/scanners/test_get_scanners.py @@ -8,36 +8,40 @@ class GmpGetScannersTestMixin: def test_get_scanners(self): self.gmp.get_scanners() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_scanners_with_filter_string(self): self.gmp.get_scanners(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scanners_with_filter_id(self): self.gmp.get_scanners(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scanners_with_trash(self): self.gmp.get_scanners(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_scanners(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_scanners_with_details(self): self.gmp.get_scanners(details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_scanners(details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) diff --git a/tests/protocols/gmpv224/entities/scanners/test_modify_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_modify_scanner.py index 5abbe8d4a..54b56df9d 100644 --- a/tests/protocols/gmpv224/entities/scanners/test_modify_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_modify_scanner.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv224 import ScannerType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import ScannerType class GmpModifyScannerTestMixin: @@ -12,7 +12,7 @@ def test_modify_scanner(self): self.gmp.modify_scanner(scanner_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_scanner_missing_scanner_id(self): @@ -26,62 +26,62 @@ def test_modify_scanner_with_comment(self): self.gmp.modify_scanner(scanner_id="s1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scanner_with_host(self): self.gmp.modify_scanner(scanner_id="s1", host="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scanner_with_port(self): self.gmp.modify_scanner(scanner_id="s1", port=1234) self.connection.send.has_been_called_with( - '' - "1234" - "" + b'' + b"1234" + b"" ) self.gmp.modify_scanner(scanner_id="s1", port="1234") self.connection.send.has_been_called_with( - '' - "1234" - "" + b'' + b"1234" + b"" ) def test_modify_scanner_with_name(self): self.gmp.modify_scanner(scanner_id="s1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scanner_with_ca_pub(self): self.gmp.modify_scanner(scanner_id="s1", ca_pub="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_scanner_with_credential_id(self): self.gmp.modify_scanner(scanner_id="s1", credential_id="c1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_scanner_with_scanner_type(self): @@ -90,9 +90,9 @@ def test_modify_scanner_with_scanner_type(self): ) self.connection.send.has_been_called_with( - '' - "2" - "" + b'' + b"2" + b"" ) self.gmp.modify_scanner( @@ -100,9 +100,9 @@ def test_modify_scanner_with_scanner_type(self): ) self.connection.send.has_been_called_with( - '' - "3" - "" + b'' + b"3" + b"" ) self.gmp.modify_scanner( @@ -111,17 +111,17 @@ def test_modify_scanner_with_scanner_type(self): ) self.connection.send.has_been_called_with( - '' - "5" - "" + b'' + b"5" + b"" ) def test_modify_scanner_invalid_scanner_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(ValueError): self.gmp.modify_scanner(scanner_id="s1", scanner_type="") - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_scanner(scanner_id="s1", scanner_type="-1") - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_scanner(scanner_id="s1", scanner_type=1) diff --git a/tests/protocols/gmpv208/entities/scanners/test_verify_scanner.py b/tests/protocols/gmpv224/entities/scanners/test_verify_scanner.py similarity index 90% rename from tests/protocols/gmpv208/entities/scanners/test_verify_scanner.py rename to tests/protocols/gmpv224/entities/scanners/test_verify_scanner.py index b49d9718d..d543b55b1 100644 --- a/tests/protocols/gmpv208/entities/scanners/test_verify_scanner.py +++ b/tests/protocols/gmpv224/entities/scanners/test_verify_scanner.py @@ -11,7 +11,7 @@ def test_verify(self): self.gmp.verify_scanner("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/schedules/__init__.py b/tests/protocols/gmpv224/entities/schedules/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/schedules/__init__.py rename to tests/protocols/gmpv224/entities/schedules/__init__.py diff --git a/tests/protocols/gmpv208/entities/schedules/test_clone_schedule.py b/tests/protocols/gmpv224/entities/schedules/test_clone_schedule.py similarity index 88% rename from tests/protocols/gmpv208/entities/schedules/test_clone_schedule.py rename to tests/protocols/gmpv224/entities/schedules/test_clone_schedule.py index d3c5a4154..a24c500c0 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_clone_schedule.py +++ b/tests/protocols/gmpv224/entities/schedules/test_clone_schedule.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_schedule("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/schedules/test_create_schedule.py b/tests/protocols/gmpv224/entities/schedules/test_create_schedule.py similarity index 96% rename from tests/protocols/gmpv208/entities/schedules/test_create_schedule.py rename to tests/protocols/gmpv224/entities/schedules/test_create_schedule.py index f20b841c7..c97aae919 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_create_schedule.py +++ b/tests/protocols/gmpv224/entities/schedules/test_create_schedule.py @@ -68,7 +68,7 @@ def test_create_schedule(self): "foo" f"{ICAL}" "Europe/Berlin" - "" + "".encode("utf-8") ) def test_create_schedule_with_comment(self): @@ -82,5 +82,5 @@ def test_create_schedule_with_comment(self): f"{ICAL}" "Europe/Berlin" "bar" - "" + "".encode("utf-8") ) diff --git a/tests/protocols/gmpv208/entities/schedules/test_delete_schedule.py b/tests/protocols/gmpv224/entities/schedules/test_delete_schedule.py similarity index 83% rename from tests/protocols/gmpv208/entities/schedules/test_delete_schedule.py rename to tests/protocols/gmpv224/entities/schedules/test_delete_schedule.py index 8c406b2ba..026e5736b 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_delete_schedule.py +++ b/tests/protocols/gmpv224/entities/schedules/test_delete_schedule.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_schedule("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_schedule("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/schedules/test_get_schedule.py b/tests/protocols/gmpv224/entities/schedules/test_get_schedule.py similarity index 81% rename from tests/protocols/gmpv208/entities/schedules/test_get_schedule.py rename to tests/protocols/gmpv224/entities/schedules/test_get_schedule.py index ba5bc3899..8c08c0312 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_get_schedule.py +++ b/tests/protocols/gmpv224/entities/schedules/test_get_schedule.py @@ -11,13 +11,13 @@ def test_get_schedule(self): self.gmp.get_schedule("s1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_schedule(schedule_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_schedule_missing_schedule_id(self): @@ -31,11 +31,11 @@ def test_get_schedules_with_tasks(self): self.gmp.get_schedule(schedule_id="s1", tasks=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_schedule(schedule_id="s1", tasks=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/schedules/test_get_schedules.py b/tests/protocols/gmpv224/entities/schedules/test_get_schedules.py similarity index 62% rename from tests/protocols/gmpv208/entities/schedules/test_get_schedules.py rename to tests/protocols/gmpv224/entities/schedules/test_get_schedules.py index 55c8f17f6..f057c7c49 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_get_schedules.py +++ b/tests/protocols/gmpv224/entities/schedules/test_get_schedules.py @@ -8,36 +8,36 @@ class GmpGetSchedulesTestMixin: def test_get_schedules(self): self.gmp.get_schedules() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_schedules_with_filter_string(self): self.gmp.get_schedules(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_schedules_with_filter_id(self): self.gmp.get_schedules(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_schedules_with_trash(self): self.gmp.get_schedules(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_schedules(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_schedules_with_tasks(self): self.gmp.get_schedules(tasks=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_schedules(tasks=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/schedules/test_modify_schedule.py b/tests/protocols/gmpv224/entities/schedules/test_modify_schedule.py similarity index 79% rename from tests/protocols/gmpv208/entities/schedules/test_modify_schedule.py rename to tests/protocols/gmpv224/entities/schedules/test_modify_schedule.py index b71ec559f..ae846bcde 100644 --- a/tests/protocols/gmpv208/entities/schedules/test_modify_schedule.py +++ b/tests/protocols/gmpv224/entities/schedules/test_modify_schedule.py @@ -36,18 +36,18 @@ def test_modify_schedule_with_name(self): self.gmp.modify_schedule(schedule_id="s1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_schedule_with_comment(self): self.gmp.modify_schedule(schedule_id="s1", comment="bar") self.connection.send.has_been_called_with( - '' - "bar" - "" + b'' + b"bar" + b"" ) def test_modify_schedule_with_icalendar(self): @@ -56,14 +56,14 @@ def test_modify_schedule_with_icalendar(self): self.connection.send.has_been_called_with( '' f"{ICAL}" - "" + "".encode("utf-8") ) def test_modify_schedule_with_timezone(self): self.gmp.modify_schedule(schedule_id="s1", timezone="Europe/Berlin") self.connection.send.has_been_called_with( - '' - "Europe/Berlin" - "" + b'' + b"Europe/Berlin" + b"" ) diff --git a/tests/protocols/gmpv208/entities/secinfo/__init__.py b/tests/protocols/gmpv224/entities/secinfo/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/secinfo/__init__.py rename to tests/protocols/gmpv224/entities/secinfo/__init__.py diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisories.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisories.py similarity index 74% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisories.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisories.py index a30c3c64e..9a505b5b2 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisories.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisories.py @@ -9,39 +9,39 @@ def test_get_cpes(self): self.gmp.get_cert_bund_advisories() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_filter_string(self): self.gmp.get_cert_bund_advisories(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_filter_id(self): self.gmp.get_cert_bund_advisories(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_name(self): self.gmp.get_cert_bund_advisories(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_details(self): self.gmp.get_cert_bund_advisories(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cert_bund_advisories(details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisory.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisory.py similarity index 84% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisory.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisory.py index 9dd4deaba..10e8d8817 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cert_bund_advisory.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cert_bund_advisory.py @@ -11,13 +11,13 @@ def test_get_cert_bund_advisory(self): self.gmp.get_cert_bund_advisory(cert_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cert_bund_advisory("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cert_bund_advisory_missing_cert_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cpe.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cpe.py similarity index 84% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cpe.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cpe.py index 757133f58..57159c56a 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cpe.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cpe.py @@ -11,13 +11,13 @@ def test_get_cpe(self): self.gmp.get_cpe(cpe_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cpe("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cpe_missing_cpe_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cpes.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cpes.py similarity index 72% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cpes.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cpes.py index da916d1c7..4c5ab595e 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cpes.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cpes.py @@ -8,38 +8,38 @@ class GmpGetCpeListTestMixin: def test_get_cpes(self): self.gmp.get_cpes() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_cpes_with_filter_string(self): self.gmp.get_cpes(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cpes_with_filter_id(self): self.gmp.get_cpes(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cpes_with_name(self): self.gmp.get_cpes(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cpes_with_details(self): self.gmp.get_cpes(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cpes(details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cve.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cve.py similarity index 84% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cve.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cve.py index a96cba1f4..5c690e110 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cve.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cve.py @@ -11,13 +11,13 @@ def test_get_cve(self): self.gmp.get_cve(cve_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cve("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cve_missing_cve_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_cves.py b/tests/protocols/gmpv224/entities/secinfo/test_get_cves.py similarity index 72% rename from tests/protocols/gmpv208/entities/secinfo/test_get_cves.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_cves.py index 7938d27bf..e56a357d3 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_cves.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_cves.py @@ -8,38 +8,38 @@ class GmpGetCveListTestMixin: def test_get_cpes(self): self.gmp.get_cves() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_cves_with_filter_string(self): self.gmp.get_cves(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_filter_id(self): self.gmp.get_cves(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_name(self): self.gmp.get_cves(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_details(self): self.gmp.get_cves(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_cves(details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisories.py b/tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisories.py similarity index 75% rename from tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisories.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisories.py index 4ded764a7..ed0ab3f10 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisories.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisories.py @@ -9,39 +9,39 @@ def test_get_cpes(self): self.gmp.get_dfn_cert_advisories() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_filter_string(self): self.gmp.get_dfn_cert_advisories(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_filter_id(self): self.gmp.get_dfn_cert_advisories(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_name(self): self.gmp.get_dfn_cert_advisories(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cves_with_details(self): self.gmp.get_dfn_cert_advisories(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_dfn_cert_advisories(details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisory.py b/tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisory.py similarity index 84% rename from tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisory.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisory.py index d7cc5706b..491c7acae 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_dfn_cert_advisory.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_dfn_cert_advisory.py @@ -11,13 +11,13 @@ def test_get_cert_bund_advisory(self): self.gmp.get_dfn_cert_advisory(cert_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_dfn_cert_advisory("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_cert_bund_advisory_missing_cert_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_info.py b/tests/protocols/gmpv224/entities/secinfo/test_get_info.py similarity index 77% rename from tests/protocols/gmpv208/entities/secinfo/test_get_info.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_info.py index b7565ab26..35bdee44d 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_info.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_info.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import InfoType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import InfoType class GmpGetInfoTestMixin: @@ -12,37 +12,37 @@ def test_get_info(self): self.gmp.get_info(info_type=InfoType.CERT_BUND_ADV, info_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info("i1", InfoType.CPE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info("i1", InfoType.CVE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info("i1", InfoType.DFN_CERT_ADV) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info("i1", InfoType.OVALDEF) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info("i1", InfoType.NVT) self.connection.send.has_been_called_with( - '' + b'' ) with self.assertRaises(AttributeError): @@ -61,7 +61,7 @@ def test_get_info_missing_info_type(self): self.gmp.get_info("i1", "") def test_get_info_invalid_info_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_info(info_id="i1", info_type="foo") def test_get_info_missing_info_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_info_list.py b/tests/protocols/gmpv224/entities/secinfo/test_get_info_list.py similarity index 70% rename from tests/protocols/gmpv208/entities/secinfo/test_get_info_list.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_info_list.py index 0bcd1e366..34c05439e 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_info_list.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_info_list.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import InfoType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import InfoType class GmpGetInfoListTestMixin: @@ -12,34 +12,34 @@ def test_get_info_list(self): self.gmp.get_info_list(InfoType.CERT_BUND_ADV) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info_list(InfoType.CPE) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_info_list(info_type=InfoType.CPE) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_info_list(InfoType.CVE) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_info_list(InfoType.DFN_CERT_ADV) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info_list(InfoType.OVALDEF) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_info_list(InfoType.NVT) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') with self.assertRaises(AttributeError): self.gmp.get_info_list( @@ -57,39 +57,39 @@ def test_get_info_list_missing_info_type(self): self.gmp.get_info_list("") def test_get_info_list_invalid_info_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_info_list(info_type="foo") def test_get_info_list_with_filter_string(self): self.gmp.get_info_list(InfoType.CPE, filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_info_list_with_filter_id(self): self.gmp.get_info_list(info_type=InfoType.CPE, filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_info_list_with_name(self): self.gmp.get_info_list(info_type=InfoType.CPE, name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_info_list_with_details(self): self.gmp.get_info_list(info_type=InfoType.CPE, details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_info_list(info_type=InfoType.CPE, details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt.py b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt.py similarity index 82% rename from tests/protocols/gmpv208/entities/secinfo/test_get_nvt.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_nvt.py index d0144afd1..5caa6ebf5 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt.py @@ -11,13 +11,13 @@ def test_get_nvt(self): self.gmp.get_nvt(nvt_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_nvt("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_nvt_missing_nvt_id(self): @@ -34,10 +34,8 @@ def test_get_extended_nvt_with_nvt_oid(self): self.gmp.get_nvt(extended=True, nvt_id="nvt_oid") self.connection.send.has_been_called_with( - ( - '' - ) + b'' ) def test_get_extended_nvt_missing_nvt_oid(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_families.py b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_families.py similarity index 74% rename from tests/protocols/gmpv208/entities/secinfo/test_get_nvt_families.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_nvt_families.py index ab9c3e2ad..36e35b9e5 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_families.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_families.py @@ -8,11 +8,11 @@ class GmpGetNvtFamiliesTestMixin: def test_get_nvt_families(self): self.gmp.get_nvt_families() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_nvt_families_with_sort_order(self): self.gmp.get_nvt_families(sort_order="foo") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preference.py b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preference.py similarity index 87% rename from tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preference.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preference.py index de02c619c..1a6ff12f3 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preference.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preference.py @@ -11,7 +11,7 @@ def test_get_preference(self): self.gmp.get_nvt_preference(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_nvt_preference_missing_name(self): @@ -28,5 +28,5 @@ def test_get_nvt_preference_with_nvt_oid(self): self.gmp.get_nvt_preference(name="foo", nvt_oid="oid") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preferences.py b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preferences.py similarity index 76% rename from tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preferences.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preferences.py index ac7c5dd2c..2ac9220a8 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_nvt_preferences.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_nvt_preferences.py @@ -8,11 +8,11 @@ class GmpGetNvtPreferencesTestMixin: def test_get_nvt_preferences(self): self.gmp.get_nvt_preferences() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_nvt_preferences_with_nvt_oid(self): self.gmp.get_nvt_preferences(nvt_oid="oid") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_nvts.py b/tests/protocols/gmpv224/entities/secinfo/test_get_nvts.py similarity index 66% rename from tests/protocols/gmpv208/entities/secinfo/test_get_nvts.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_nvts.py index b7da77c92..da8fc27b3 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_nvts.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_nvts.py @@ -8,86 +8,90 @@ class GmpGetNvtListTestMixin: def test_get_nvts(self): self.gmp.get_nvts() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_nvts_with_filter_string(self): self.gmp.get_nvts(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_nvts_with_filter_id(self): self.gmp.get_nvts(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_nvts_with_name(self): self.gmp.get_nvts(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_nvts_with_details(self): self.gmp.get_nvts(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_nvts(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_extended_nvts(self): self.gmp.get_nvts(extended=True) - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_extended_nvts_with_details(self): self.gmp.get_nvts(extended=True, details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_nvts(extended=True, details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_extended_nvts_with_preferences(self): self.gmp.get_nvts(extended=True, preferences=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_nvts(extended=True, preferences=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_extended_nvts_with_preference_count(self): self.gmp.get_nvts(extended=True, preference_count=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_extended_nvts_with_timeout(self): self.gmp.get_nvts(extended=True, timeout=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_nvts(extended=True, timeout=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_extended_nvts_with_config_id(self): self.gmp.get_nvts(extended=True, config_id="config_id") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_extended_nvts_with_preferences_config_id(self): @@ -96,24 +100,26 @@ def test_get_extended_nvts_with_preferences_config_id(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_extended_nvts_with_family(self): self.gmp.get_nvts(extended=True, family="family") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_extended_nvts_with_sort_order(self): self.gmp.get_nvts(extended=True, sort_order="sort_order") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_extended_nvts_with_sort_field(self): self.gmp.get_nvts(extended=True, sort_field="sort_field") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_oval_definition.py b/tests/protocols/gmpv224/entities/secinfo/test_get_oval_definition.py similarity index 85% rename from tests/protocols/gmpv208/entities/secinfo/test_get_oval_definition.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_oval_definition.py index b9c2e9be0..fb391c435 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_oval_definition.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_oval_definition.py @@ -11,13 +11,13 @@ def test_get_oval_definition(self): self.gmp.get_oval_definition(oval_id="i1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_oval_definition("i1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_oval_definition_missing_oval_id(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_oval_definitions.py b/tests/protocols/gmpv224/entities/secinfo/test_get_oval_definitions.py similarity index 74% rename from tests/protocols/gmpv208/entities/secinfo/test_get_oval_definitions.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_oval_definitions.py index be24f2ed9..53bdce07f 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_oval_definitions.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_oval_definitions.py @@ -8,38 +8,38 @@ class GmpGetOvalDefListTestMixin: def test_get_oval_definitions(self): self.gmp.get_oval_definitions() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_oval_definitions_with_filter_string(self): self.gmp.get_oval_definitions(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_oval_definitions_with_filter_id(self): self.gmp.get_oval_definitions(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_oval_definitions_with_name(self): self.gmp.get_oval_definitions(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_oval_definitions_with_details(self): self.gmp.get_oval_definitions(details=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_oval_definitions(details=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvt.py b/tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvt.py similarity index 83% rename from tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvt.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvt.py index d622b3843..f30da86bb 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvt.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvt.py @@ -11,10 +11,8 @@ def test_get_scan_config_nvt_with_nvt_oid(self): self.gmp.get_scan_config_nvt(nvt_oid="nvt_oid") self.connection.send.has_been_called_with( - ( - '' - ) + b'' ) def test_get_scan_config_nvt_missing_nvt_oid(self): diff --git a/tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvts.py b/tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvts.py similarity index 65% rename from tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvts.py rename to tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvts.py index 4d6d22d2d..1ad95a169 100644 --- a/tests/protocols/gmpv208/entities/secinfo/test_get_scan_config_nvts.py +++ b/tests/protocols/gmpv224/entities/secinfo/test_get_scan_config_nvts.py @@ -8,47 +8,51 @@ class GmpGetScanConfigNvtsTestMixin: def test_get_scan_config_nvts_simple(self): self.gmp.get_scan_config_nvts() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_scan_config_nvts_with_details(self): self.gmp.get_scan_config_nvts(details=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_scan_config_nvts(details=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_scan_config_nvts_with_preferences(self): self.gmp.get_scan_config_nvts(preferences=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_scan_config_nvts(preferences=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_scan_config_nvts_with_preference_count(self): self.gmp.get_scan_config_nvts(preference_count=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_nvts_with_timeout(self): self.gmp.get_scan_config_nvts(timeout=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_scan_config_nvts(timeout=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_scan_config_nvts_with_config_id(self): self.gmp.get_scan_config_nvts(config_id="config_id") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_nvts_with_preferences_config_id(self): @@ -57,24 +61,26 @@ def test_get_scan_config_nvts_with_preferences_config_id(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_nvts_with_family(self): self.gmp.get_scan_config_nvts(family="family") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_scan_config_nvts_with_sort_order(self): self.gmp.get_scan_config_nvts(sort_order="sort_order") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scan_config_nvts_with_sort_field(self): self.gmp.get_scan_config_nvts(sort_field="sort_field") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/tags/__init__.py b/tests/protocols/gmpv224/entities/tags/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/tags/__init__.py rename to tests/protocols/gmpv224/entities/tags/__init__.py diff --git a/tests/protocols/gmpv208/entities/tags/test_clone_tag.py b/tests/protocols/gmpv224/entities/tags/test_clone_tag.py similarity index 89% rename from tests/protocols/gmpv208/entities/tags/test_clone_tag.py rename to tests/protocols/gmpv224/entities/tags/test_clone_tag.py index 38d3e34ec..ed6dcf333 100644 --- a/tests/protocols/gmpv208/entities/tags/test_clone_tag.py +++ b/tests/protocols/gmpv224/entities/tags/test_clone_tag.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_tag("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tags/test_create_tag.py b/tests/protocols/gmpv224/entities/tags/test_create_tag.py similarity index 63% rename from tests/protocols/gmpv208/entities/tags/test_create_tag.py rename to tests/protocols/gmpv224/entities/tags/test_create_tag.py index 5d2219105..ba3202251 100644 --- a/tests/protocols/gmpv208/entities/tags/test_create_tag.py +++ b/tests/protocols/gmpv224/entities/tags/test_create_tag.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import EntityType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import EntityType class GmpCreateTagTestMixin: @@ -28,12 +28,12 @@ def test_create_tag_missing_resource_filter_and_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - "task" - "" - "" + b"" + b"foo" + b"" + b"task" + b"" + b"" ) self.gmp.create_tag( @@ -44,23 +44,23 @@ def test_create_tag_missing_resource_filter_and_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - "task" - "" - "" + b"" + b"foo" + b"" + b"task" + b"" + b"" ) self.gmp.create_tag(name="foo", resource_type=EntityType.TASK) self.connection.send.has_been_called_with( - "" - "foo" - "" - "task" - "" - "" + b"" + b"foo" + b"" + b"task" + b"" + b"" ) def test_create_tag_both_resource_filter_and_ids(self): @@ -73,7 +73,7 @@ def test_create_tag_both_resource_filter_and_ids(self): ) def test_create_tag_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_tag( name="foo", resource_type="Foo", @@ -111,12 +111,12 @@ def test_create_tag_with_resource_filter(self): ) self.connection.send.has_been_called_with( - "" - "foo" - '' - "task" - "" - "" + b"" + b"foo" + b'' + b"task" + b"" + b"" ) def test_create_tag_with_resource_filter_audit(self): @@ -127,12 +127,12 @@ def test_create_tag_with_resource_filter_audit(self): ) self.connection.send.has_been_called_with( - "" - "foo" - '' - "task" - "" - "" + b"" + b"foo" + b'' + b"task" + b"" + b"" ) def test_create_tag_with_resource_filter_policy(self): @@ -143,12 +143,12 @@ def test_create_tag_with_resource_filter_policy(self): ) self.connection.send.has_been_called_with( - "" - "foo" - '' - "config" - "" - "" + b"" + b"foo" + b'' + b"config" + b"" + b"" ) def test_create_tag_with_resource_ids(self): @@ -157,13 +157,13 @@ def test_create_tag_with_resource_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - "task" - "" - "" + b"" + b"foo" + b"" + b'' + b"task" + b"" + b"" ) self.gmp.create_tag( @@ -173,14 +173,14 @@ def test_create_tag_with_resource_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - '' - "task" - "" - "" + b"" + b"foo" + b"" + b'' + b'' + b"task" + b"" + b"" ) def test_create_tag_with_comment(self): @@ -192,14 +192,14 @@ def test_create_tag_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - "task" - "" - "bar" - "" + b"" + b"foo" + b"" + b'' + b"task" + b"" + b"bar" + b"" ) def test_create_tag_with_value(self): @@ -211,14 +211,14 @@ def test_create_tag_with_value(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - "task" - "" - "bar" - "" + b"" + b"foo" + b"" + b'' + b"task" + b"" + b"bar" + b"" ) def test_create_tag_with_active(self): @@ -230,14 +230,14 @@ def test_create_tag_with_active(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - "task" - "" - "1" - "" + b"" + b"foo" + b"" + b'' + b"task" + b"" + b"1" + b"" ) self.gmp.create_tag( @@ -248,12 +248,12 @@ def test_create_tag_with_active(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "" - '' - "task" - "" - "0" - "" + b"" + b"foo" + b"" + b'' + b"task" + b"" + b"0" + b"" ) diff --git a/tests/protocols/gmpv208/entities/tags/test_delete_tag.py b/tests/protocols/gmpv224/entities/tags/test_delete_tag.py similarity index 85% rename from tests/protocols/gmpv208/entities/tags/test_delete_tag.py rename to tests/protocols/gmpv224/entities/tags/test_delete_tag.py index d1a779fbd..b3bd0f72f 100644 --- a/tests/protocols/gmpv208/entities/tags/test_delete_tag.py +++ b/tests/protocols/gmpv224/entities/tags/test_delete_tag.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_tag("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_tag("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tags/test_get_tag.py b/tests/protocols/gmpv224/entities/tags/test_get_tag.py similarity index 75% rename from tests/protocols/gmpv208/entities/tags/test_get_tag.py rename to tests/protocols/gmpv224/entities/tags/test_get_tag.py index 6e712e627..e1a6caed9 100644 --- a/tests/protocols/gmpv208/entities/tags/test_get_tag.py +++ b/tests/protocols/gmpv224/entities/tags/test_get_tag.py @@ -10,11 +10,11 @@ class GmpGetTagTestMixin: def test_get_tag(self): self.gmp.get_tag("t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_tag(tag_id="t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_tag_missing_tag_id(self): with self.assertRaises(RequiredArgument): diff --git a/tests/protocols/gmpv208/entities/tags/test_get_tags.py b/tests/protocols/gmpv224/entities/tags/test_get_tags.py similarity index 57% rename from tests/protocols/gmpv208/entities/tags/test_get_tags.py rename to tests/protocols/gmpv224/entities/tags/test_get_tags.py index 1cbfeae4b..a65586729 100644 --- a/tests/protocols/gmpv208/entities/tags/test_get_tags.py +++ b/tests/protocols/gmpv224/entities/tags/test_get_tags.py @@ -8,34 +8,34 @@ class GmpGetTagsTestMixin: def test_get_tags(self): self.gmp.get_tags() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_tags_with_filter_string(self): self.gmp.get_tags(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tags_with_filter_id(self): self.gmp.get_tags(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_tags_with_trash(self): self.gmp.get_tags(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_tags(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_tags_with_names_only(self): self.gmp.get_tags(names_only=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_tags(names_only=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/tags/test_modify_tag.py b/tests/protocols/gmpv224/entities/tags/test_modify_tag.py similarity index 63% rename from tests/protocols/gmpv208/entities/tags/test_modify_tag.py rename to tests/protocols/gmpv224/entities/tags/test_modify_tag.py index b9fbd56a4..07eb3d170 100644 --- a/tests/protocols/gmpv208/entities/tags/test_modify_tag.py +++ b/tests/protocols/gmpv224/entities/tags/test_modify_tag.py @@ -3,15 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import EntityType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import EntityType class GmpModifyTagTestMixin: def test_modify_tag(self): self.gmp.modify_tag(tag_id="t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_modify_tag_missing_tag_id(self): with self.assertRaises(RequiredArgument): @@ -24,34 +24,34 @@ def test_modify_tag_with_comment(self): self.gmp.modify_tag(tag_id="t1", comment="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_tag_with_value(self): self.gmp.modify_tag(tag_id="t1", value="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_tag_with_name(self): self.gmp.modify_tag(tag_id="t1", name="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_tag_with_active(self): self.gmp.modify_tag(tag_id="t1", active=True) self.connection.send.has_been_called_with( - '1' + b'1' ) self.gmp.modify_tag(tag_id="t1", active=False) self.connection.send.has_been_called_with( - '0' + b'0' ) def test_modify_tag_with_resource_filter_and_type(self): @@ -62,11 +62,11 @@ def test_modify_tag_with_resource_filter_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "task" - "" - "" + b'' + b'' + b"task" + b"" + b"" ) def test_modify_tag_with_resource_filter_and_type_audit(self): @@ -77,11 +77,11 @@ def test_modify_tag_with_resource_filter_and_type_audit(self): ) self.connection.send.has_been_called_with( - '' - '' - "task" - "" - "" + b'' + b'' + b"task" + b"" + b"" ) def test_modify_tag_with_resource_filter_and_type_policy(self): @@ -92,11 +92,11 @@ def test_modify_tag_with_resource_filter_and_type_policy(self): ) self.connection.send.has_been_called_with( - '' - '' - "config" - "" - "" + b'' + b'' + b"config" + b"" + b"" ) def test_modify_tag_with_resource_action_filter_and_type(self): @@ -108,11 +108,11 @@ def test_modify_tag_with_resource_action_filter_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - "task" - "" - "" + b'' + b'' + b"task" + b"" + b"" ) def test_modify_tag_with_resource_ids_and_type(self): @@ -121,12 +121,12 @@ def test_modify_tag_with_resource_ids_and_type(self): ) self.connection.send.has_been_called_with( - '' - "" - '' - "task" - "" - "" + b'' + b"" + b'' + b"task" + b"" + b"" ) def test_modify_tag_with_resource_action_ids_and_type(self): @@ -138,39 +138,39 @@ def test_modify_tag_with_resource_action_ids_and_type(self): ) self.connection.send.has_been_called_with( - '' - '' - '' - "task" - "" - "" + b'' + b'' + b'' + b"task" + b"" + b"" ) def test_modify_tag_with_missing_resource_filter_or_ids_andtype(self): self.gmp.modify_tag(tag_id="t1", resource_action="add") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_tag_with_missing_resource_type(self): self.gmp.modify_tag(tag_id="t1", resource_ids=["r1"]) self.connection.send.has_been_called_with( - '' - "" - '' - "" - "" + b'' + b"" + b'' + b"" + b"" ) with self.assertRaises(RequiredArgument): self.gmp.modify_tag(tag_id="t1", resource_filter="name=foo") def test_modify_tag_with_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_tag( tag_id="t1", resource_type="foo", resource_filter="name=foo" ) @@ -179,9 +179,9 @@ def test_modify_tag_with_missing_resource_filter_and_ids(self): self.gmp.modify_tag(tag_id="t1", resource_type=EntityType.TASK) self.connection.send.has_been_called_with( - '' - "" - "task" - "" - "" + b'' + b"" + b"task" + b"" + b"" ) diff --git a/tests/protocols/gmpv224/entities/targets/__init__.py b/tests/protocols/gmpv224/entities/targets/__init__.py index 46d7dceb7..27b214c3a 100644 --- a/tests/protocols/gmpv224/entities/targets/__init__.py +++ b/tests/protocols/gmpv224/entities/targets/__init__.py @@ -3,7 +3,18 @@ # SPDX-License-Identifier: GPL-3.0-or-later # +from .test_clone_target import GmpCloneTargetTestMixin from .test_create_target import GmpCreateTargetTestMixin +from .test_delete_target import GmpDeleteTargetTestMixin +from .test_get_target import GmpGetTargetTestMixin +from .test_get_targets import GmpGetTargetsTestMixin from .test_modify_target import GmpModifyTargetTestMixin -__all__ = ("GmpCreateTargetTestMixin", "GmpModifyTargetTestMixin") +__all__ = ( + "GmpCloneTargetTestMixin", + "GmpCreateTargetTestMixin", + "GmpDeleteTargetTestMixin", + "GmpGetTargetTestMixin", + "GmpGetTargetsTestMixin", + "GmpModifyTargetTestMixin", +) diff --git a/tests/protocols/gmpv208/entities/targets/test_clone_target.py b/tests/protocols/gmpv224/entities/targets/test_clone_target.py similarity index 93% rename from tests/protocols/gmpv208/entities/targets/test_clone_target.py rename to tests/protocols/gmpv224/entities/targets/test_clone_target.py index bd5ebd42c..9c8e88314 100644 --- a/tests/protocols/gmpv208/entities/targets/test_clone_target.py +++ b/tests/protocols/gmpv224/entities/targets/test_clone_target.py @@ -15,7 +15,7 @@ def test_clone(self): self.connection.send.has_been_called_with( "" f"{self.TARGET_ID}" - "" + "".encode("utf-8") ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/targets/test_create_target.py b/tests/protocols/gmpv224/entities/targets/test_create_target.py index 24e50bf73..0ba9a3022 100644 --- a/tests/protocols/gmpv224/entities/targets/test_create_target.py +++ b/tests/protocols/gmpv224/entities/targets/test_create_target.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv224 import AliveTest +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import AliveTest class GmpCreateTargetTestMixin: @@ -22,10 +22,10 @@ def test_create_target_with_asset_hosts_filter(self): self.gmp.create_target("foo", asset_hosts_filter="name=foo") self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) def test_create_target_missing_hosts(self): @@ -36,11 +36,11 @@ def test_create_target_with_comment(self): self.gmp.create_target("foo", hosts=["foo"], comment="bar") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - "" + b"" + b"foo" + b"foo" + b"bar" + b"" ) def test_create_target_with_exclude_hosts(self): @@ -49,22 +49,22 @@ def test_create_target_with_exclude_hosts(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "foo,bar" - "bar,ipsum" - "" + b"" + b"foo" + b"foo,bar" + b"bar,ipsum" + b"" ) def test_create_target_with_ssh_credential(self): self.gmp.create_target("foo", hosts=["foo"], ssh_credential_id="c1") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" + b"" + b"foo" + b"foo" + b'' + b"" ) def test_create_target_with_ssh_credential_port(self): @@ -76,46 +76,46 @@ def test_create_target_with_ssh_credential_port(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "123" - "" - "" + b"" + b"foo" + b"foo" + b'' + b"123" + b"" + b"" ) def test_create_target_with_smb_credential_id(self): self.gmp.create_target("foo", hosts=["foo"], smb_credential_id="c1") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" + b"" + b"foo" + b"foo" + b'' + b"" ) def test_create_target_with_esxi_credential_id(self): self.gmp.create_target("foo", hosts=["foo"], esxi_credential_id="c1") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" + b"" + b"foo" + b"foo" + b'' + b"" ) def test_create_target_with_snmp_credential_id(self): self.gmp.create_target("foo", hosts=["foo"], snmp_credential_id="c1") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" + b"" + b"foo" + b"foo" + b'' + b"" ) def test_create_target_with_alive_tests(self): @@ -124,15 +124,15 @@ def test_create_target_with_alive_tests(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "ICMP Ping" - "" + b"" + b"foo" + b"foo" + b"ICMP Ping" + b"" ) def test_create_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_target("foo", hosts=["foo"], alive_test="foo") def test_create_target_with_allow_simultaneous_ips(self): @@ -141,11 +141,11 @@ def test_create_target_with_allow_simultaneous_ips(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" + b"" + b"foo" + b"foo" + b"1" + b"" ) self.gmp.create_target( @@ -153,73 +153,73 @@ def test_create_target_with_allow_simultaneous_ips(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" + b"" + b"foo" + b"foo" + b"0" + b"" ) def test_create_target_with_reverse_lookup_only(self): self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_only=True) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" + b"" + b"foo" + b"foo" + b"1" + b"" ) self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_only=False) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" + b"" + b"foo" + b"foo" + b"0" + b"" ) def test_create_target_with_reverse_lookup_unify(self): self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_unify=True) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "1" - "" + b"" + b"foo" + b"foo" + b"1" + b"" ) self.gmp.create_target("foo", hosts=["foo"], reverse_lookup_unify=False) self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "0" - "" + b"" + b"foo" + b"foo" + b"0" + b"" ) def test_create_target_with_port_range(self): self.gmp.create_target("foo", hosts=["foo"], port_range="bar") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - "bar" - "" + b"" + b"foo" + b"foo" + b"bar" + b"" ) def test_create_target_with_port_list_id(self): self.gmp.create_target("foo", hosts=["foo"], port_list_id="pl1") self.connection.send.has_been_called_with( - "" - "foo" - "foo" - '' - "" + b"" + b"foo" + b"foo" + b'' + b"" ) diff --git a/tests/protocols/gmpv208/entities/targets/test_delete_target.py b/tests/protocols/gmpv224/entities/targets/test_delete_target.py similarity index 84% rename from tests/protocols/gmpv208/entities/targets/test_delete_target.py rename to tests/protocols/gmpv224/entities/targets/test_delete_target.py index f947f7bd9..f31e2e4d7 100644 --- a/tests/protocols/gmpv208/entities/targets/test_delete_target.py +++ b/tests/protocols/gmpv224/entities/targets/test_delete_target.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_target("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_target("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/targets/test_get_target.py b/tests/protocols/gmpv224/entities/targets/test_get_target.py similarity index 82% rename from tests/protocols/gmpv208/entities/targets/test_get_target.py rename to tests/protocols/gmpv224/entities/targets/test_get_target.py index bfc9eb25f..b0836d383 100644 --- a/tests/protocols/gmpv208/entities/targets/test_get_target.py +++ b/tests/protocols/gmpv224/entities/targets/test_get_target.py @@ -11,13 +11,13 @@ def test_get_target(self): self.gmp.get_target("t1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_target(target_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_target_missing_target_id(self): @@ -31,11 +31,11 @@ def test_get_target_with_tasks(self): self.gmp.get_target(target_id="t1", tasks=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_target(target_id="t1", tasks=False) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/targets/test_get_targets.py b/tests/protocols/gmpv224/entities/targets/test_get_targets.py similarity index 57% rename from tests/protocols/gmpv208/entities/targets/test_get_targets.py rename to tests/protocols/gmpv224/entities/targets/test_get_targets.py index cf4afb482..1f56f8505 100644 --- a/tests/protocols/gmpv208/entities/targets/test_get_targets.py +++ b/tests/protocols/gmpv224/entities/targets/test_get_targets.py @@ -8,34 +8,36 @@ class GmpGetTargetsTestMixin: def test_get_targets(self): self.gmp.get_targets() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_targets_with_filter_string(self): self.gmp.get_targets(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_targets_with_filter_id(self): self.gmp.get_targets(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_targets_with_trash(self): self.gmp.get_targets(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_targets(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_targets_with_tasks(self): self.gmp.get_targets(tasks=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_targets(tasks=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv224/entities/targets/test_modify_target.py b/tests/protocols/gmpv224/entities/targets/test_modify_target.py index 4ab53e914..2f8b762e3 100644 --- a/tests/protocols/gmpv224/entities/targets/test_modify_target.py +++ b/tests/protocols/gmpv224/entities/targets/test_modify_target.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv214.entities.targets import AliveTest +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import AliveTest class GmpModifyTargetTestMixin: @@ -12,7 +12,7 @@ def test_modify_target(self): self.gmp.modify_target(target_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_target_missing_target_id(self): @@ -26,28 +26,28 @@ def test_modify_target_with_comment(self): self.gmp.modify_target(target_id="t1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_target_with_hosts(self): self.gmp.modify_target(target_id="t1", hosts=["foo"]) self.connection.send.has_been_called_with( - '' - "foo" - "" - "" + b'' + b"foo" + b"" + b"" ) self.gmp.modify_target(target_id="t1", hosts=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - "foo,bar" - "" - "" + b'' + b"foo,bar" + b"" + b"" ) def test_modify_target_with_hosts_and_exclude_hosts(self): @@ -56,45 +56,45 @@ def test_modify_target_with_hosts_and_exclude_hosts(self): ) self.connection.send.has_been_called_with( - '' - "foo,bar" - "foo" - "" + b'' + b"foo,bar" + b"foo" + b"" ) def test_modify_target_with_name(self): self.gmp.modify_target(target_id="t1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_target_with_exclude_hosts(self): self.gmp.modify_target(target_id="t1", exclude_hosts=["foo"]) self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) self.gmp.modify_target(target_id="t1", exclude_hosts=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - "foo,bar" - "" + b'' + b"foo,bar" + b"" ) def test_modify_target_with_ssh_credential(self): self.gmp.modify_target(target_id="t1", ssh_credential_id="c1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_target_with_ssh_credential_port(self): @@ -103,109 +103,109 @@ def test_modify_target_with_ssh_credential_port(self): ) self.connection.send.has_been_called_with( - '' - '' - "123" - "" - "" + b'' + b'' + b"123" + b"" + b"" ) def test_modify_target_with_smb_credential_id(self): self.gmp.modify_target(target_id="t1", smb_credential_id="c1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_target_with_esxi_credential_id(self): self.gmp.modify_target(target_id="t1", esxi_credential_id="c1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_target_with_snmp_credential_id(self): self.gmp.modify_target(target_id="t1", snmp_credential_id="c1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) def test_modify_target_with_alive_tests(self): self.gmp.modify_target(target_id="t1", alive_test=AliveTest.ICMP_PING) self.connection.send.has_been_called_with( - '' - "ICMP Ping" - "" + b'' + b"ICMP Ping" + b"" ) def test_modify_target_invalid_alive_tests(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_target(target_id="t1", alive_test="foo") def test_modify_target_with_allow_simultaneous_ips(self): self.gmp.modify_target(target_id="t1", allow_simultaneous_ips=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_target(target_id="t1", allow_simultaneous_ips=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_target_with_reverse_lookup_only(self): self.gmp.modify_target(target_id="t1", reverse_lookup_only=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_target(target_id="t1", reverse_lookup_only=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_target_with_reverse_lookup_unify(self): self.gmp.modify_target(target_id="t1", reverse_lookup_unify=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_target(target_id="t1", reverse_lookup_unify=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_target_with_port_list_id(self): self.gmp.modify_target(target_id="t1", port_list_id="pl1") self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) diff --git a/tests/protocols/gmpv208/entities/tasks/__init__.py b/tests/protocols/gmpv224/entities/tasks/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/tasks/__init__.py rename to tests/protocols/gmpv224/entities/tasks/__init__.py diff --git a/tests/protocols/gmpv208/entities/tasks/test_clone_task.py b/tests/protocols/gmpv224/entities/tasks/test_clone_task.py similarity index 89% rename from tests/protocols/gmpv208/entities/tasks/test_clone_task.py rename to tests/protocols/gmpv224/entities/tasks/test_clone_task.py index 54678006f..72db6d9ea 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_clone_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_clone_task.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_task("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tasks/test_create_container_task.py b/tests/protocols/gmpv224/entities/tasks/test_create_container_task.py similarity index 72% rename from tests/protocols/gmpv208/entities/tasks/test_create_container_task.py rename to tests/protocols/gmpv224/entities/tasks/test_create_container_task.py index 323e82e2e..8f0aed46b 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_create_container_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_create_container_task.py @@ -11,10 +11,10 @@ def test_create_task(self): self.gmp.create_container_task(name="foo") self.connection.send.has_been_called_with( - "" - "foo" - '' - "" + b"" + b"foo" + b'' + b"" ) def test_create_task_missing_name(self): @@ -28,9 +28,9 @@ def test_create_task_with_comment(self): self.gmp.create_container_task(name="foo", comment="bar") self.connection.send.has_been_called_with( - "" - "foo" - '' - "bar" - "" + b"" + b"foo" + b'' + b"bar" + b"" ) diff --git a/tests/protocols/gmpv208/entities/tasks/test_create_task.py b/tests/protocols/gmpv224/entities/tasks/test_create_task.py similarity index 56% rename from tests/protocols/gmpv208/entities/tasks/test_create_task.py rename to tests/protocols/gmpv224/entities/tasks/test_create_task.py index e8f011bb9..1a9cfc1a6 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_create_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_create_task.py @@ -5,8 +5,8 @@ from collections import OrderedDict -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import HostsOrdering +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import HostsOrdering class GmpCreateTaskTestMixin: @@ -16,13 +16,13 @@ def test_create_task(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"" ) def test_create_task_missing_name(self): @@ -79,14 +79,14 @@ def test_create_task_with_comment(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "bar" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"bar" + b"" ) def test_create_task_single_alert(self): @@ -100,14 +100,14 @@ def test_create_task_single_alert(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - '' - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b'' + b"" ) def test_create_task_multiple_alerts(self): @@ -120,28 +120,18 @@ def test_create_task_multiple_alerts(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - '' - '' - '' - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b'' + b'' + b'' + b"" ) - def test_create_task_invalid_alerts(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_task( - name="foo", - config_id="c1", - target_id="t1", - scanner_id="s1", - alert_ids="invalid", - ) - def test_create_task_with_empty_alert_ids(self): self.gmp.create_task( name="foo", @@ -152,13 +142,13 @@ def test_create_task_with_empty_alert_ids(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"" ) def test_create_task_with_alterable(self): @@ -171,14 +161,14 @@ def test_create_task_with_alterable(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "1" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"1" + b"" ) self.gmp.create_task( @@ -190,14 +180,14 @@ def test_create_task_with_alterable(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "0" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"0" + b"" ) def test_create_task_with_hosts_ordering(self): @@ -210,18 +200,18 @@ def test_create_task_with_hosts_ordering(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "reverse" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"reverse" + b"" ) def test_create_task_invalid_hosts_ordering(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.create_task( name="foo", config_id="c1", @@ -240,14 +230,14 @@ def test_create_task_with_schedule(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - '' - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b'' + b"" ) def test_create_task_with_schedule_and_schedule_periods(self): @@ -261,15 +251,15 @@ def test_create_task_with_schedule_and_schedule_periods(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - '' - "0" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b'' + b"0" + b"" ) self.gmp.create_task( @@ -282,15 +272,15 @@ def test_create_task_with_schedule_and_schedule_periods(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - '' - "5" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b'' + b"5" + b"" ) def test_create_task_with_schedule_and_invalid_schedule_periods(self): @@ -324,35 +314,16 @@ def test_create_task_with_observers(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "u1,u2" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"u1,u2" + b"" ) - def test_create_task_invalid_observers(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_task( - name="foo", - config_id="c1", - target_id="t1", - scanner_id="s1", - observers="", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_task( - name="foo", - config_id="c1", - target_id="t1", - scanner_id="s1", - observers="foo", - ) - def test_create_task_with_preferences(self): self.gmp.create_task( name="foo", @@ -363,44 +334,25 @@ def test_create_task_with_preferences(self): ) self.connection.send.has_been_called_with( - "" - "foo" - "scan" - '' - '' - '' - "" - "" - "foo" - "bar" - "" - "" - "lorem" - "ipsum" - "" - "" - "" + b"" + b"foo" + b"scan" + b'' + b'' + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"" ) - def test_create_task_invalid_preferences(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.create_task( - name="foo", - config_id="c1", - target_id="t1", - scanner_id="s1", - preferences="", - ) - - with self.assertRaises(InvalidArgumentType): - self.gmp.create_task( - name="foo", - config_id="c1", - target_id="t1", - scanner_id="s1", - preferences=["foo", "bar"], - ) - def test_create_task_don_t_allow_container_task(self): with self.assertRaises(InvalidArgument): self.gmp.create_task( diff --git a/tests/protocols/gmpv208/entities/tasks/test_delete_task.py b/tests/protocols/gmpv224/entities/tasks/test_delete_task.py similarity index 84% rename from tests/protocols/gmpv208/entities/tasks/test_delete_task.py rename to tests/protocols/gmpv224/entities/tasks/test_delete_task.py index aa0f8dd92..7b0a69132 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_delete_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_delete_task.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_task("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_task("a1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tasks/test_get_task.py b/tests/protocols/gmpv224/entities/tasks/test_get_task.py similarity index 87% rename from tests/protocols/gmpv208/entities/tasks/test_get_task.py rename to tests/protocols/gmpv224/entities/tasks/test_get_task.py index ebb826b98..e3b2fb699 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_get_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_get_task.py @@ -11,7 +11,7 @@ def test_get_task(self): self.gmp.get_task("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_fail_without_task_id(self): diff --git a/tests/protocols/gmpv208/entities/tasks/test_get_tasks.py b/tests/protocols/gmpv224/entities/tasks/test_get_tasks.py similarity index 74% rename from tests/protocols/gmpv208/entities/tasks/test_get_tasks.py rename to tests/protocols/gmpv224/entities/tasks/test_get_tasks.py index 1771cbd2e..b41e11d09 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_get_tasks.py +++ b/tests/protocols/gmpv224/entities/tasks/test_get_tasks.py @@ -9,47 +9,47 @@ def test_get_tasks_simple(self): self.gmp.get_tasks() self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_with_filter_string(self): self.gmp.get_tasks(filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_with_filter_id(self): self.gmp.get_tasks(filter_id="f1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_from_trash(self): self.gmp.get_tasks(trash=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_with_details(self): self.gmp.get_tasks(details=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_without_details(self): self.gmp.get_tasks(details=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tasks_with_schedules_only(self): self.gmp.get_tasks(schedules_only=True) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/tasks/test_modify_task.py b/tests/protocols/gmpv224/entities/tasks/test_modify_task.py similarity index 55% rename from tests/protocols/gmpv208/entities/tasks/test_modify_task.py rename to tests/protocols/gmpv224/entities/tasks/test_modify_task.py index d6c63f00a..4e5a8688e 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_modify_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_modify_task.py @@ -5,15 +5,17 @@ from collections import OrderedDict -from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import HostsOrdering +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import HostsOrdering class GmpModifyTaskTestMixin: def test_modify_task(self): self.gmp.modify_task("t1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_modify_task_missing_task_id(self): with self.assertRaises(RequiredArgument): @@ -29,123 +31,116 @@ def test_modify_task_with_name(self): self.gmp.modify_task(task_id="t1", name="foo") self.connection.send.has_been_called_with( - 'foo' + b'foo' ) def test_modify_task_with_config_id(self): self.gmp.modify_task(task_id="t1", config_id="c1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_target_id(self): self.gmp.modify_task(task_id="t1", target_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_scanner_id(self): self.gmp.modify_task(task_id="t1", scanner_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_schedule_id(self): self.gmp.modify_task(task_id="t1", schedule_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_comment(self): self.gmp.modify_task(task_id="t1", comment="bar") self.connection.send.has_been_called_with( - '' - "bar" - "" + b'' + b"bar" + b"" ) def test_modify_task_with_alerts_ids(self): self.gmp.modify_task(task_id="t1", alert_ids=["a1", "a2", "a3"]) self.connection.send.has_been_called_with( - '' - '' - '' - '' - "" + b'' + b'' + b'' + b'' + b"" ) - def test_modify_task_invalid_alerts_ids(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", alert_ids="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", alert_ids="a1") - def test_modify_task_with_empty_alert_ids(self): self.gmp.modify_task(task_id="t1", alert_ids=[]) self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_alterable(self): self.gmp.modify_task(task_id="t1", alterable=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_task(task_id="t1", alterable=False) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) def test_modify_task_with_hosts_ordering(self): self.gmp.modify_task(task_id="t1", hosts_ordering=HostsOrdering.REVERSE) self.connection.send.has_been_called_with( - '' - "reverse" - "" + b'' + b"reverse" + b"" ) def test_modify_task_invalid_hosts_ordering(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_task(task_id="t1", hosts_ordering="foo") def test_modify_task_with_schedule(self): self.gmp.modify_task(task_id="t1", schedule_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_task_with_schedule_periods(self): self.gmp.modify_task(task_id="t1", schedule_periods=0) self.connection.send.has_been_called_with( - '' - "0" - "" + b'' + b"0" + b"" ) self.gmp.modify_task(task_id="t1", schedule_periods=5) self.connection.send.has_been_called_with( - '' - "5" - "" + b'' + b"5" + b"" ) def test_modify_task_invalid_schedule_periods(self): @@ -159,18 +154,11 @@ def test_modify_task_with_observers(self): self.gmp.modify_task(task_id="t1", observers=["u1", "u2"]) self.connection.send.has_been_called_with( - '' - "u1,u2" - "" + b'' + b"u1,u2" + b"" ) - def test_modify_task_invalid_observers(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", observers="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", observers="foo") - def test_modify_task_with_preferences(self): self.gmp.modify_task( task_id="t1", @@ -178,23 +166,16 @@ def test_modify_task_with_preferences(self): ) self.connection.send.has_been_called_with( - '' - "" - "" - "foo" - "bar" - "" - "" - "lorem" - "ipsum" - "" - "" - "" + b'' + b"" + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"" ) - - def test_modify_task_invalid_preferences(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", preferences="") - - with self.assertRaises(InvalidArgumentType): - self.gmp.modify_task(task_id="t1", preferences=["foo", "bar"]) diff --git a/tests/protocols/gmpv208/entities/tasks/test_move_task.py b/tests/protocols/gmpv224/entities/tasks/test_move_task.py similarity index 80% rename from tests/protocols/gmpv208/entities/tasks/test_move_task.py rename to tests/protocols/gmpv224/entities/tasks/test_move_task.py index 0392ae3fb..6898abbc6 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_move_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_move_task.py @@ -10,13 +10,13 @@ class GmpMoveTaskTestMixin: def test_move_task(self): self.gmp.move_task("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_move_task_to_slave(self): self.gmp.move_task("a1", slave_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tasks/test_resume_task.py b/tests/protocols/gmpv224/entities/tasks/test_resume_task.py similarity index 80% rename from tests/protocols/gmpv208/entities/tasks/test_resume_task.py rename to tests/protocols/gmpv224/entities/tasks/test_resume_task.py index 0ced95ca8..1b63a90f6 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_resume_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_resume_task.py @@ -10,7 +10,9 @@ class GmpResumeTaskTestMixin: def test_resume_task(self): self.gmp.resume_task("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/tasks/test_start_task.py b/tests/protocols/gmpv224/entities/tasks/test_start_task.py similarity index 83% rename from tests/protocols/gmpv208/entities/tasks/test_start_task.py rename to tests/protocols/gmpv224/entities/tasks/test_start_task.py index 3251f674f..a8553c560 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_start_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_start_task.py @@ -10,7 +10,7 @@ class GmpStartTaskTestMixin: def test_start_task(self): self.gmp.start_task("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/entities/tasks/test_stop_task.py b/tests/protocols/gmpv224/entities/tasks/test_stop_task.py similarity index 83% rename from tests/protocols/gmpv208/entities/tasks/test_stop_task.py rename to tests/protocols/gmpv224/entities/tasks/test_stop_task.py index 09c1d4526..fe11bfa8a 100644 --- a/tests/protocols/gmpv208/entities/tasks/test_stop_task.py +++ b/tests/protocols/gmpv224/entities/tasks/test_stop_task.py @@ -10,7 +10,7 @@ class GmpStopTaskTestMixin: def test_stop_task(self): self.gmp.stop_task("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv224/entities/test_alerts.py b/tests/protocols/gmpv224/entities/test_alerts.py index ad04ace22..66b1eb5df 100644 --- a/tests/protocols/gmpv224/entities/test_alerts.py +++ b/tests/protocols/gmpv224/entities/test_alerts.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.alerts import ( +from ...gmpv224 import Gmpv224TestCase +from .alerts import ( GmpCloneAlertTestMixin, GmpCreateAlertTestMixin, GmpDeleteAlertTestMixin, @@ -13,7 +14,6 @@ GmpTestAlertTestMixin, GmpTriggerAlertTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CloneAlertTestCase(GmpCloneAlertTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_audits.py b/tests/protocols/gmpv224/entities/test_audits.py index 73ff14450..3d24347d4 100644 --- a/tests/protocols/gmpv224/entities/test_audits.py +++ b/tests/protocols/gmpv224/entities/test_audits.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.audits import ( +from ...gmpv224 import Gmpv224TestCase +from .audits import ( GmpCloneAuditTestMixin, GmpCreateAuditTestMixin, GmpDeleteAuditTestMixin, @@ -14,7 +15,6 @@ GmpStartAuditTestMixin, GmpStopAuditTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CloneAuditTestCase(GmpCloneAuditTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_credentials.py b/tests/protocols/gmpv224/entities/test_credentials.py index d80dc7478..a684794d5 100644 --- a/tests/protocols/gmpv224/entities/test_credentials.py +++ b/tests/protocols/gmpv224/entities/test_credentials.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.credentials import ( +from ...gmpv224 import Gmpv224TestCase +from .credentials import ( GmpCloneCredentialTestMixin, GmpCreateCredentialTestMixin, GmpDeleteCredentialTestMixin, @@ -11,7 +12,6 @@ GmpGetCredentialTestMixin, GmpModifyCredentialTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CloneCredentialTestCase( diff --git a/tests/protocols/gmpv224/entities/test_filters.py b/tests/protocols/gmpv224/entities/test_filters.py index 104ad3ac9..7e51a4eb1 100644 --- a/tests/protocols/gmpv224/entities/test_filters.py +++ b/tests/protocols/gmpv224/entities/test_filters.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.filters import ( +from ...gmpv224 import Gmpv224TestCase +from .filters import ( GmpCloneFilterTestMixin, GmpCreateFilterTestMixin, GmpDeleteFilterTestMixin, @@ -11,7 +12,6 @@ GmpGetFilterTestMixin, GmpModifyFilterTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteFilterTestCase(GmpDeleteFilterTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_groups.py b/tests/protocols/gmpv224/entities/test_groups.py index eb34fae0a..52edecebc 100644 --- a/tests/protocols/gmpv224/entities/test_groups.py +++ b/tests/protocols/gmpv224/entities/test_groups.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.groups import ( +from ...gmpv224 import Gmpv224TestCase +from .groups import ( GmpCloneGroupTestMixin, GmpCreateGroupTestMixin, GmpDeleteGroupTestMixin, @@ -11,7 +12,6 @@ GmpGetGroupTestMixin, GmpModifyGroupTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteGroupTestCase(GmpDeleteGroupTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_hosts.py b/tests/protocols/gmpv224/entities/test_hosts.py index e4a8d0cec..0fc187a3b 100644 --- a/tests/protocols/gmpv224/entities/test_hosts.py +++ b/tests/protocols/gmpv224/entities/test_hosts.py @@ -3,14 +3,14 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.hosts import ( +from ...gmpv224 import Gmpv224TestCase +from .hosts import ( GmpCreateHostTestMixin, GmpDeleteHostTestMixin, GmpGetHostsTestMixin, GmpGetHostTestMixin, GmpModifyHostTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CreateHostTestCase(GmpCreateHostTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_notes.py b/tests/protocols/gmpv224/entities/test_notes.py index adce4da57..8b025d6c3 100644 --- a/tests/protocols/gmpv224/entities/test_notes.py +++ b/tests/protocols/gmpv224/entities/test_notes.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.notes import ( +from ...gmpv224 import Gmpv224TestCase +from .notes import ( GmpCloneNoteTestMixin, + GmpCreateNoteTestMixin, GmpDeleteNoteTestMixin, GmpGetNotesTestMixin, GmpGetNoteTestMixin, + GmpModifyNoteTestMixin, ) -from ...gmpv224 import Gmpv224TestCase -from .notes import GmpCreateNoteTestMixin, GmpModifyNoteTestMixin class Gmpv224DeleteNoteTestCase(GmpDeleteNoteTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_operating_systems.py b/tests/protocols/gmpv224/entities/test_operating_systems.py index 0ba1a4c68..9fd80fb20 100644 --- a/tests/protocols/gmpv224/entities/test_operating_systems.py +++ b/tests/protocols/gmpv224/entities/test_operating_systems.py @@ -3,13 +3,13 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.operating_systems import ( +from ...gmpv224 import Gmpv224TestCase +from .operating_systems import ( GmpDeleteOperatingSystemTestMixin, GmpGetOperatingSystemsTestMixin, GmpGetOperatingSystemTestMixin, GmpModifyOperatingSystemTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteOperatingSystemTestCase( diff --git a/tests/protocols/gmpv224/entities/test_overrides.py b/tests/protocols/gmpv224/entities/test_overrides.py index cb57a94c8..71820b393 100644 --- a/tests/protocols/gmpv224/entities/test_overrides.py +++ b/tests/protocols/gmpv224/entities/test_overrides.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.overrides import ( +from ...gmpv224 import Gmpv224TestCase +from .overrides import ( GmpCloneOverrideTestMixin, + GmpCreateOverrideTestMixin, GmpDeleteOverrideTestMixin, GmpGetOverridesTestMixin, GmpGetOverrideTestMixin, + GmpModifyOverrideTestMixin, ) -from ...gmpv224 import Gmpv224TestCase -from .overrides import GmpCreateOverrideTestMixin, GmpModifyOverrideTestMixin class Gmpv224CloneOverrideTestCase(GmpCloneOverrideTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_permissions.py b/tests/protocols/gmpv224/entities/test_permissions.py index 4fc527f8b..bb13d33af 100644 --- a/tests/protocols/gmpv224/entities/test_permissions.py +++ b/tests/protocols/gmpv224/entities/test_permissions.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.permissions import ( +from ...gmpv224 import Gmpv224TestCase +from .permissions import ( GmpClonePermissionTestMixin, GmpCreatePermissionTestMixin, GmpDeletePermissionTestMixin, @@ -11,7 +12,6 @@ GmpGetPermissionTestMixin, GmpModifyPermissionTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeletePermissionTestCase( diff --git a/tests/protocols/gmpv224/entities/test_policies.py b/tests/protocols/gmpv224/entities/test_policies.py index 584a60556..6e60f91a5 100644 --- a/tests/protocols/gmpv224/entities/test_policies.py +++ b/tests/protocols/gmpv224/entities/test_policies.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.policies import ( +from ...gmpv224 import Gmpv224TestCase +from .policies import ( GmpClonePolicyTestMixin, GmpCreatePolicyTestMixin, GmpDeletePolicyTestMixin, @@ -17,7 +18,6 @@ GmpModifyPolicySetNvtSelectionTestMixin, GmpModifyPolicySetScannerPreferenceTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224ClonePolicyTestCase(GmpClonePolicyTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_port_lists.py b/tests/protocols/gmpv224/entities/test_port_lists.py index 634dc1517..856553d2c 100644 --- a/tests/protocols/gmpv224/entities/test_port_lists.py +++ b/tests/protocols/gmpv224/entities/test_port_lists.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.port_lists import ( +from ...gmpv224 import Gmpv224TestCase +from .port_lists import ( GmpClonePortListTestMixin, GmpCreatePortListTestMixin, GmpCreatePortRangeTestMixin, @@ -13,7 +14,6 @@ GmpGetPortListTestMixin, GmpModifyPortListTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224ClonePortListTestCase(GmpClonePortListTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_report_formats.py b/tests/protocols/gmpv224/entities/test_report_formats.py index c57e5483c..07a37b4d0 100644 --- a/tests/protocols/gmpv224/entities/test_report_formats.py +++ b/tests/protocols/gmpv224/entities/test_report_formats.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.report_formats import ( +from ...gmpv224 import Gmpv224TestCase +from .report_formats import ( GmpCloneReportFormatTestMixin, GmpDeleteReportFormatTestMixin, GmpGetReportFormatsTestMixin, @@ -12,7 +13,6 @@ GmpModifyReportFormatTestMixin, GmpVerifyReportFormatTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteReportFormatTestCase( diff --git a/tests/protocols/gmpv224/entities/test_reports.py b/tests/protocols/gmpv224/entities/test_reports.py index 195506bb7..36232ebca 100644 --- a/tests/protocols/gmpv224/entities/test_reports.py +++ b/tests/protocols/gmpv224/entities/test_reports.py @@ -3,13 +3,13 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.reports import ( +from ...gmpv224 import Gmpv224TestCase +from .reports import ( GmpDeleteReportTestMixin, GmpGetReportsTestMixin, GmpGetReportTestMixin, GmpImportReportTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteReportTestCase(GmpDeleteReportTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_results.py b/tests/protocols/gmpv224/entities/test_results.py index 751b9b294..028f2d86f 100644 --- a/tests/protocols/gmpv224/entities/test_results.py +++ b/tests/protocols/gmpv224/entities/test_results.py @@ -3,11 +3,11 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.results import ( +from ...gmpv224 import Gmpv224TestCase +from .results import ( GmpGetResultsTestMixin, GmpGetResultTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224GetResultTestCase(GmpGetResultTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_roles.py b/tests/protocols/gmpv224/entities/test_roles.py index 6c04a3a79..1fcd02c08 100644 --- a/tests/protocols/gmpv224/entities/test_roles.py +++ b/tests/protocols/gmpv224/entities/test_roles.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.roles import ( +from ...gmpv224 import Gmpv224TestCase +from .roles import ( GmpCloneRoleTestMixin, GmpCreateRoleTestMixin, GmpDeleteRoleTestMixin, @@ -11,7 +12,6 @@ GmpGetRoleTestMixin, GmpModifyRoleTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteRoleTestCase(GmpDeleteRoleTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_scan_configs.py b/tests/protocols/gmpv224/entities/test_scan_configs.py index 013772fbb..caad7a56d 100644 --- a/tests/protocols/gmpv224/entities/test_scan_configs.py +++ b/tests/protocols/gmpv224/entities/test_scan_configs.py @@ -4,7 +4,7 @@ # from ...gmpv224 import Gmpv224TestCase -from ...gmpv224.entities.scan_configs import ( +from .scan_configs import ( GmpCloneScanConfigTestMixin, GmpCreateScanConfigTestMixin, GmpDeleteScanConfigTestMixin, @@ -17,7 +17,6 @@ GmpModifyScanConfigSetNvtPreferenceTestMixin, GmpModifyScanConfigSetNvtSelectionTestMixin, GmpModifyScanConfigSetScannerPreferenceTestMixin, - GmpModifyScanConfigTestMixin, ) @@ -89,9 +88,3 @@ class Gmpv224ModifyScanConfigSetScannerPreferenceTestCase( GmpModifyScanConfigSetScannerPreferenceTestMixin, Gmpv224TestCase ): pass - - -class Gmpv224ModifyScanConfigTestCase( - GmpModifyScanConfigTestMixin, Gmpv224TestCase -): - pass diff --git a/tests/protocols/gmpv224/entities/test_scanners.py b/tests/protocols/gmpv224/entities/test_scanners.py index 444389a08..15d490596 100644 --- a/tests/protocols/gmpv224/entities/test_scanners.py +++ b/tests/protocols/gmpv224/entities/test_scanners.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.scanners import ( +from ...gmpv224 import Gmpv224TestCase +from .scanners import ( GmpCloneScannerTestMixin, + GmpCreateScannerTestMixin, GmpDeleteScannerTestMixin, GmpGetScannersTestMixin, GmpGetScannerTestMixin, + GmpModifyScannerTestMixin, ) -from ...gmpv224 import Gmpv224TestCase -from .scanners import GmpCreateScannerTestMixin, GmpModifyScannerTestMixin class Gmpv224DeleteScannerTestCase(GmpDeleteScannerTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_schedules.py b/tests/protocols/gmpv224/entities/test_schedules.py index 0df248593..c030d7308 100644 --- a/tests/protocols/gmpv224/entities/test_schedules.py +++ b/tests/protocols/gmpv224/entities/test_schedules.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.schedules import ( +from ...gmpv224 import Gmpv224TestCase +from .schedules import ( GmpCloneScheduleTestMixin, GmpCreateScheduleTestMixin, GmpDeleteScheduleTestMixin, @@ -11,7 +12,6 @@ GmpGetScheduleTestMixin, GmpModifyScheduleTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteScheduleTestCase( diff --git a/tests/protocols/gmpv224/entities/test_secinfo.py b/tests/protocols/gmpv224/entities/test_secinfo.py index ace7591a3..fd2f26468 100644 --- a/tests/protocols/gmpv224/entities/test_secinfo.py +++ b/tests/protocols/gmpv224/entities/test_secinfo.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.secinfo import ( +from ...gmpv224 import Gmpv224TestCase +from .secinfo import ( GmpGetCertBundListTestMixin, GmpGetCertBundTestMixin, GmpGetCpeListTestMixin, @@ -17,12 +18,9 @@ GmpGetNvtFamiliesTestMixin, GmpGetNvtListTestMixin, GmpGetNvtTestMixin, - GmpGetOvalDefListTestMixin, - GmpGetOvalDefTestMixin, GmpGetScanConfigNvtsTestMixin, GmpGetScanConfigNvtTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224GetCertBundTestCase(GmpGetCertBundTestMixin, Gmpv224TestCase): @@ -41,10 +39,6 @@ class Gmpv224GetDfnCertCase(GmpGetDfnCertTestMixin, Gmpv224TestCase): pass -class Gmpv224GetOvalDefCase(GmpGetOvalDefTestMixin, Gmpv224TestCase): - pass - - class Gmpv224GetInfoListTestCase(GmpGetInfoListTestMixin, Gmpv224TestCase): pass @@ -95,9 +89,3 @@ class Gmpv224GetDfnCertListCase(GmpGetDfnCertListTestMixin, Gmpv224TestCase): class Gmpv224GetNvtListTestCase(GmpGetNvtListTestMixin, Gmpv224TestCase): pass - - -class Gmpv224GetOvalDefListTestCase( - GmpGetOvalDefListTestMixin, Gmpv224TestCase -): - pass diff --git a/tests/protocols/gmpv224/entities/test_tags.py b/tests/protocols/gmpv224/entities/test_tags.py index 11a10a8e7..278de3c29 100644 --- a/tests/protocols/gmpv224/entities/test_tags.py +++ b/tests/protocols/gmpv224/entities/test_tags.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tags import ( +from ...gmpv224 import Gmpv224TestCase +from .tags import ( GmpCloneTagTestMixin, GmpCreateTagTestMixin, GmpDeleteTagTestMixin, @@ -11,7 +12,6 @@ GmpGetTagTestMixin, GmpModifyTagTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteTagTestCase(GmpDeleteTagTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_targets.py b/tests/protocols/gmpv224/entities/test_targets.py index 6c73bd2f0..ceec10327 100644 --- a/tests/protocols/gmpv224/entities/test_targets.py +++ b/tests/protocols/gmpv224/entities/test_targets.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.targets import ( +from ...gmpv224 import Gmpv224TestCase +from .targets import ( GmpCloneTargetTestMixin, + GmpCreateTargetTestMixin, GmpDeleteTargetTestMixin, GmpGetTargetsTestMixin, GmpGetTargetTestMixin, + GmpModifyTargetTestMixin, ) -from ...gmpv224 import Gmpv224TestCase -from .targets import GmpCreateTargetTestMixin, GmpModifyTargetTestMixin class Gmpv224CloneTargetTestCase(GmpCloneTargetTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_tasks.py b/tests/protocols/gmpv224/entities/test_tasks.py index 6fbe1dfaf..59101d7f3 100644 --- a/tests/protocols/gmpv224/entities/test_tasks.py +++ b/tests/protocols/gmpv224/entities/test_tasks.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tasks import ( +from ...gmpv224 import Gmpv224TestCase +from .tasks import ( GmpCloneTaskTestMixin, GmpCreateContainerTaskTestMixin, GmpCreateTaskTestMixin, @@ -16,7 +17,6 @@ GmpStartTaskTestMixin, GmpStopTaskTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CloneTaskTestCase(GmpCloneTaskTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_tickets.py b/tests/protocols/gmpv224/entities/test_tickets.py index b240949db..7009c651b 100644 --- a/tests/protocols/gmpv224/entities/test_tickets.py +++ b/tests/protocols/gmpv224/entities/test_tickets.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tickets import ( +from ...gmpv224 import Gmpv224TestCase +from .tickets import ( GmpCloneTicketTestMixin, GmpCreateTicketTestMixin, GmpDeleteTicketTestMixin, @@ -11,7 +12,6 @@ GmpGetTicketTestMixin, GmpModifyTicketTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224DeleteTicketTestCase(GmpDeleteTicketTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_tls_certificates.py b/tests/protocols/gmpv224/entities/test_tls_certificates.py index 4e04065be..ebc68bfd6 100644 --- a/tests/protocols/gmpv224/entities/test_tls_certificates.py +++ b/tests/protocols/gmpv224/entities/test_tls_certificates.py @@ -3,7 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tls_certificates import ( +from ...gmpv224 import Gmpv224TestCase +from .tls_certificates import ( GmpCloneTLSCertificateTestMixin, GmpCreateTLSCertificateTestMixin, GmpDeleteTLSCertificateTestMixin, @@ -11,7 +12,6 @@ GmpGetTLSCertificateTestMixin, GmpModifyTLSCertificateTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224CloneTLSCertificateTestCase( diff --git a/tests/protocols/gmpv224/entities/test_users.py b/tests/protocols/gmpv224/entities/test_users.py index e2d781813..20da5f357 100644 --- a/tests/protocols/gmpv224/entities/test_users.py +++ b/tests/protocols/gmpv224/entities/test_users.py @@ -3,14 +3,15 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.users import ( +from ...gmpv224 import Gmpv224TestCase +from .users import ( GmpCloneUserTestMixin, + GmpCreateUserTestMixin, GmpDeleteUserTestMixin, GmpGetUsersTestMixin, GmpGetUserTestMixin, + GmpModifyUserTestMixin, ) -from ...gmpv224 import Gmpv224TestCase -from .users import GmpCreateUserTestMixin, GmpModifyUserTestMixin class Gmpv224CloneUserTestCase(GmpCloneUserTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/entities/test_vulnerabilities.py b/tests/protocols/gmpv224/entities/test_vulnerabilities.py index e9717423d..c53f9836a 100644 --- a/tests/protocols/gmpv224/entities/test_vulnerabilities.py +++ b/tests/protocols/gmpv224/entities/test_vulnerabilities.py @@ -3,11 +3,11 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.vulnerabilities import ( +from ...gmpv224 import Gmpv224TestCase +from .vulnerabilities import ( GmpGetVulnerabilitiesTestMixin, GmpGetVulnerabilityTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224GetVulnerabilityTestCase( diff --git a/tests/protocols/gmpv208/entities/tickets/__init__.py b/tests/protocols/gmpv224/entities/tickets/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/tickets/__init__.py rename to tests/protocols/gmpv224/entities/tickets/__init__.py diff --git a/tests/protocols/gmpv208/entities/tickets/test_clone_ticket.py b/tests/protocols/gmpv224/entities/tickets/test_clone_ticket.py similarity index 85% rename from tests/protocols/gmpv208/entities/tickets/test_clone_ticket.py rename to tests/protocols/gmpv224/entities/tickets/test_clone_ticket.py index e537817f0..406b4fc32 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_clone_ticket.py +++ b/tests/protocols/gmpv224/entities/tickets/test_clone_ticket.py @@ -11,13 +11,13 @@ def test_clone(self): self.gmp.clone_ticket("t1") self.connection.send.has_been_called_with( - "t1" + b"t1" ) self.gmp.clone_ticket(ticket_id="t1") self.connection.send.has_been_called_with( - "t1" + b"t1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tickets/test_create_ticket.py b/tests/protocols/gmpv224/entities/tickets/test_create_ticket.py similarity index 72% rename from tests/protocols/gmpv208/entities/tickets/test_create_ticket.py rename to tests/protocols/gmpv224/entities/tickets/test_create_ticket.py index 9cd28e838..d8377f45e 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_create_ticket.py +++ b/tests/protocols/gmpv224/entities/tickets/test_create_ticket.py @@ -13,13 +13,13 @@ def test_create_ticket(self): ) self.connection.send.has_been_called_with( - "" - '' - "" - '' - "" - "lorem ipsum" - "" + b"" + b'' + b"" + b'' + b"" + b"lorem ipsum" + b"" ) def test_create_ticket_with_comment(self): @@ -31,14 +31,14 @@ def test_create_ticket_with_comment(self): ) self.connection.send.has_been_called_with( - "" - '' - "" - '' - "" - "lorem ipsum" - "bar" - "" + b"" + b'' + b"" + b'' + b"" + b"lorem ipsum" + b"bar" + b"" ) def test_create_ticket_missing_result_id(self): diff --git a/tests/protocols/gmpv208/entities/tickets/test_delete_ticket.py b/tests/protocols/gmpv224/entities/tickets/test_delete_ticket.py similarity index 84% rename from tests/protocols/gmpv208/entities/tickets/test_delete_ticket.py rename to tests/protocols/gmpv224/entities/tickets/test_delete_ticket.py index 1977f024b..06b672140 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_delete_ticket.py +++ b/tests/protocols/gmpv224/entities/tickets/test_delete_ticket.py @@ -11,14 +11,14 @@ def test_delete(self): self.gmp.delete_ticket("t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): self.gmp.delete_ticket("t1", ultimate=True) self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tickets/test_get_ticket.py b/tests/protocols/gmpv224/entities/tickets/test_get_ticket.py similarity index 87% rename from tests/protocols/gmpv208/entities/tickets/test_get_ticket.py rename to tests/protocols/gmpv224/entities/tickets/test_get_ticket.py index 3c68a5140..9002fee41 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_get_ticket.py +++ b/tests/protocols/gmpv224/entities/tickets/test_get_ticket.py @@ -11,13 +11,13 @@ def test_get_ticket(self): self.gmp.get_ticket("t1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_ticket(ticket_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_ticket_missing_user_id(self): diff --git a/tests/protocols/gmpv208/entities/tickets/test_get_tickets.py b/tests/protocols/gmpv224/entities/tickets/test_get_tickets.py similarity index 60% rename from tests/protocols/gmpv208/entities/tickets/test_get_tickets.py rename to tests/protocols/gmpv224/entities/tickets/test_get_tickets.py index beb31b619..08ec2bf8f 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_get_tickets.py +++ b/tests/protocols/gmpv224/entities/tickets/test_get_tickets.py @@ -8,25 +8,27 @@ class GmpGetTicketsTestMixin: def test_get_tickets(self): self.gmp.get_tickets() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_tickets_with_filter_string(self): self.gmp.get_tickets(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tickets_with_filter_id(self): self.gmp.get_tickets(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_get_tickets_with_trash(self): self.gmp.get_tickets(trash=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_tickets(trash=False) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/tickets/test_modify_ticket.py b/tests/protocols/gmpv224/entities/tickets/test_modify_ticket.py similarity index 67% rename from tests/protocols/gmpv208/entities/tickets/test_modify_ticket.py rename to tests/protocols/gmpv224/entities/tickets/test_modify_ticket.py index 5d3deb65b..7794153ed 100644 --- a/tests/protocols/gmpv208/entities/tickets/test_modify_ticket.py +++ b/tests/protocols/gmpv224/entities/tickets/test_modify_ticket.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import TicketStatus +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import TicketStatus class GmpModifyTicketTestMixin: @@ -12,13 +12,13 @@ def test_modify_ticket(self): self.gmp.modify_ticket("t1") self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.modify_ticket(ticket_id="t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_missing_ticket_id(self): @@ -35,24 +35,24 @@ def test_modify_ticket_with_comment(self): self.gmp.modify_ticket(ticket_id="t1", comment="bar") self.connection.send.has_been_called_with( - '' - "bar" - "" + b'' + b"bar" + b"" ) def test_modify_ticket_with_assigned_to_user_id(self): self.gmp.modify_ticket(ticket_id="t1", assigned_to_user_id="u1") self.connection.send.has_been_called_with( - '' - "" - '' - "" - "" + b'' + b"" + b'' + b"" + b"" ) def test_modify_ticket_invalid_status(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.modify_ticket(ticket_id="t1", status="foobar", note="bar") def test_modify_ticket_open(self): @@ -61,10 +61,10 @@ def test_modify_ticket_open(self): ) self.connection.send.has_been_called_with( - '' - "Open" - "lorem ipsum" - "" + b'' + b"Open" + b"lorem ipsum" + b"" ) def test_modify_ticket_fixed(self): @@ -73,10 +73,10 @@ def test_modify_ticket_fixed(self): ) self.connection.send.has_been_called_with( - '' - "Fixed" - "lorem ipsum" - "" + b'' + b"Fixed" + b"lorem ipsum" + b"" ) def test_modify_ticket_closed(self): @@ -85,10 +85,10 @@ def test_modify_ticket_closed(self): ) self.connection.send.has_been_called_with( - '' - "Closed" - "lorem ipsum" - "" + b'' + b"Closed" + b"lorem ipsum" + b"" ) def test_modify_ticket_status_without_note(self): diff --git a/tests/protocols/gmpv208/entities/tls_certificates/__init__.py b/tests/protocols/gmpv224/entities/tls_certificates/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/tls_certificates/__init__.py rename to tests/protocols/gmpv224/entities/tls_certificates/__init__.py diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_clone_tls_certificate.py b/tests/protocols/gmpv224/entities/tls_certificates/test_clone_tls_certificate.py similarity index 82% rename from tests/protocols/gmpv208/entities/tls_certificates/test_clone_tls_certificate.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_clone_tls_certificate.py index e25a14875..4c832193f 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_clone_tls_certificate.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_clone_tls_certificate.py @@ -11,9 +11,9 @@ def test_clone(self): self.gmp.clone_tls_certificate("a1") self.connection.send.has_been_called_with( - "" - "a1" - "" + b"" + b"a1" + b"" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_create_tls_certificate.py b/tests/protocols/gmpv224/entities/tls_certificates/test_create_tls_certificate.py similarity index 71% rename from tests/protocols/gmpv208/entities/tls_certificates/test_create_tls_certificate.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_create_tls_certificate.py index d65b22435..f048194e7 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_create_tls_certificate.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_create_tls_certificate.py @@ -11,21 +11,22 @@ def test_create_tls_certificate(self): self.gmp.create_tls_certificate("foo", "c1", comment="bar", trust=True) self.connection.send.has_been_called_with( - "" - "bar" - "foo" - "c1" - "1" - "" + b"" + b"foo" + b"c1" + b"bar" + b"1" + b"" ) self.gmp.create_tls_certificate("foo", "c1", trust=False) self.connection.send.has_been_called_with( - "" - "foo" - "c1" - "" + b"" + b"foo" + b"c1" + b"0" + b"" ) def test_missing_certificate(self): diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_delete_tls_certificate.py b/tests/protocols/gmpv224/entities/tls_certificates/test_delete_tls_certificate.py similarity index 91% rename from tests/protocols/gmpv208/entities/tls_certificates/test_delete_tls_certificate.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_delete_tls_certificate.py index 163a7fa0d..6324eac96 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_delete_tls_certificate.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_delete_tls_certificate.py @@ -11,7 +11,7 @@ def test_delete(self): self.gmp.delete_tls_certificate("a1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_ultimate(self): diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificate.py b/tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificate.py similarity index 81% rename from tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificate.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificate.py index 7a28fdc2a..f4889ab7e 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificate.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificate.py @@ -11,8 +11,8 @@ def test_get_tls_certificate(self): self.gmp.get_tls_certificate("t1") self.connection.send.has_been_called_with( - '' + b'' ) def test_fail_without_tls_certificate_id(self): diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificates.py b/tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificates.py similarity index 75% rename from tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificates.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificates.py index 3bd7febf8..733186e4f 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_get_tls_certificates.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_get_tls_certificates.py @@ -8,25 +8,25 @@ class GmpGetTLSCertificatesTestMixin: def test_get_tls_certificates(self): self.gmp.get_tls_certificates() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_tls_certificates_with_filter_string(self): self.gmp.get_tls_certificates(filter_string="name=foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tls_certificates_with_include_certificate_data(self): self.gmp.get_tls_certificates(include_certificate_data="1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_tls_certificates_with_details(self): self.gmp.get_tls_certificates(details="1") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/entities/tls_certificates/test_modify_tls_certificate.py b/tests/protocols/gmpv224/entities/tls_certificates/test_modify_tls_certificate.py similarity index 67% rename from tests/protocols/gmpv208/entities/tls_certificates/test_modify_tls_certificate.py rename to tests/protocols/gmpv224/entities/tls_certificates/test_modify_tls_certificate.py index 28776da0b..571c3ca8d 100644 --- a/tests/protocols/gmpv208/entities/tls_certificates/test_modify_tls_certificate.py +++ b/tests/protocols/gmpv224/entities/tls_certificates/test_modify_tls_certificate.py @@ -11,40 +11,42 @@ def test_modify_tls_certificate(self): self.gmp.modify_tls_certificate("c1") self.connection.send.has_been_called_with( - '' + b'' ) def test_modify_tls_certificate_with_name(self): self.gmp.modify_tls_certificate("c1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_tls_certificate_with_comment(self): self.gmp.modify_tls_certificate("c1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_tls_certificate_with_trust(self): self.gmp.modify_tls_certificate("c1", trust=True) self.connection.send.has_been_called_with( - '' - "1" - "" + b'' + b"1" + b"" ) self.gmp.modify_tls_certificate("c1", trust=False) self.connection.send.has_been_called_with( - '' + b'' + b"0" + b"" ) def test_missing_tls_certificate_id(self): diff --git a/tests/protocols/gmpv224/entities/users/__init__.py b/tests/protocols/gmpv224/entities/users/__init__.py index e3bfc7093..6a5ca3168 100644 --- a/tests/protocols/gmpv224/entities/users/__init__.py +++ b/tests/protocols/gmpv224/entities/users/__init__.py @@ -3,7 +3,18 @@ # SPDX-License-Identifier: GPL-3.0-or-later # +from .test_clone_user import GmpCloneUserTestMixin from .test_create_user import GmpCreateUserTestMixin +from .test_delete_user import GmpDeleteUserTestMixin +from .test_get_user import GmpGetUserTestMixin +from .test_get_users import GmpGetUsersTestMixin from .test_modify_user import GmpModifyUserTestMixin -__all__ = ("GmpCreateUserTestMixin", "GmpModifyUserTestMixin") +__all__ = ( + "GmpCloneUserTestMixin", + "GmpCreateUserTestMixin", + "GmpDeleteUserTestMixin", + "GmpGetUserTestMixin", + "GmpGetUsersTestMixin", + "GmpModifyUserTestMixin", +) diff --git a/tests/protocols/gmpv208/entities/users/test_clone_user.py b/tests/protocols/gmpv224/entities/users/test_clone_user.py similarity index 89% rename from tests/protocols/gmpv208/entities/users/test_clone_user.py rename to tests/protocols/gmpv224/entities/users/test_clone_user.py index bf97c607f..6e0481ac2 100644 --- a/tests/protocols/gmpv208/entities/users/test_clone_user.py +++ b/tests/protocols/gmpv224/entities/users/test_clone_user.py @@ -11,7 +11,7 @@ def test_clone(self): self.gmp.clone_user("a1") self.connection.send.has_been_called_with( - "a1" + b"a1" ) def test_missing_id(self): diff --git a/tests/protocols/gmpv224/entities/users/test_create_user.py b/tests/protocols/gmpv224/entities/users/test_create_user.py index 0ab3fbd6e..eea3893c9 100644 --- a/tests/protocols/gmpv224/entities/users/test_create_user.py +++ b/tests/protocols/gmpv224/entities/users/test_create_user.py @@ -3,8 +3,6 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from unittest.mock import call, patch - from gvm.errors import RequiredArgument @@ -20,91 +18,54 @@ def test_create_user(self): self.gmp.create_user(name="foo") self.connection.send.has_been_called_with( - "foo" + b"foo" ) def test_create_user_with_password(self): self.gmp.create_user(name="foo", password="bar") self.connection.send.has_been_called_with( - "" - "foo" - "bar" - "" + b"" + b"foo" + b"bar" + b"" ) def test_create_user_with_hosts(self): self.gmp.create_user(name="foo", hosts=["h1", "h2"], hosts_allow=True) self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" + b"" + b"foo" + b'h1,h2' + b"" ) self.gmp.create_user(name="foo", hosts=["h1", "h2"]) self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" + b"" + b"foo" + b'h1,h2' + b"" ) self.gmp.create_user(name="foo", hosts=["h1", "h2"], hosts_allow=False) self.connection.send.has_been_called_with( - "" - "foo" - 'h1,h2' - "" - ) - - @patch("gvm.protocols.gmpv224.entities.users.deprecation") - def test_create_user_with_ifaces(self, deprecation_mock): - self.gmp.create_user(name="foo", ifaces=["h1", "h2"], ifaces_allow=True) - - self.connection.send.has_been_called_with( - "foo" + b"" + b"foo" + b'h1,h2' + b"" ) - self.gmp.create_user(name="foo", ifaces=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "foo" - ) - - self.gmp.create_user( - name="foo", ifaces=["h1", "h2"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with( - "foo" - ) - - # pylint: disable=line-too-long - deprecation_calls = [ - call("The ifaces parameter has been removed in GMP version 224"), - call( - "The ifaces_allow parameter has been removed in GMP version 224" - ), - call("The ifaces parameter has been removed in GMP version 224"), - call("The ifaces parameter has been removed in GMP version 224"), - call( - "The ifaces_allow parameter has been removed in GMP version 224" - ), - ] - # pylint: enable=line-too-long - deprecation_mock.assert_has_calls(deprecation_calls) - def test_create_user_with_role_ids(self): self.gmp.create_user(name="foo", role_ids=["r1", "r2"]) self.connection.send.has_been_called_with( - "" - "foo" - '' - '' - "" + b"" + b"foo" + b'' + b'' + b"" ) diff --git a/tests/protocols/gmpv208/entities/users/test_delete_user.py b/tests/protocols/gmpv224/entities/users/test_delete_user.py similarity index 71% rename from tests/protocols/gmpv208/entities/users/test_delete_user.py rename to tests/protocols/gmpv224/entities/users/test_delete_user.py index d16dafdea..be6eccd9f 100644 --- a/tests/protocols/gmpv208/entities/users/test_delete_user.py +++ b/tests/protocols/gmpv224/entities/users/test_delete_user.py @@ -10,29 +10,33 @@ class GmpDeleteUserTestMixin: def test_delete_user_with_user_id(self): self.gmp.delete_user("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.delete_user(user_id="a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_delete_user_with_inheritor_id(self): self.gmp.delete_user("a1", inheritor_id="u1") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_user_with_name(self): self.gmp.delete_user(name="foo") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_delete_user_with_inheritor_name(self): self.gmp.delete_user("a1", inheritor_name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_user_missing_user_id_and_name(self): diff --git a/tests/protocols/gmpv208/entities/users/test_get_user.py b/tests/protocols/gmpv224/entities/users/test_get_user.py similarity index 75% rename from tests/protocols/gmpv208/entities/users/test_get_user.py rename to tests/protocols/gmpv224/entities/users/test_get_user.py index bfde748e1..01a074dcc 100644 --- a/tests/protocols/gmpv208/entities/users/test_get_user.py +++ b/tests/protocols/gmpv224/entities/users/test_get_user.py @@ -10,11 +10,11 @@ class GmpGetUserTestMixin: def test_get_user(self): self.gmp.get_user("u1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_user(user_id="u1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_user_missing_user_id(self): with self.assertRaises(RequiredArgument): diff --git a/tests/protocols/gmpv208/entities/users/test_get_users.py b/tests/protocols/gmpv224/entities/users/test_get_users.py similarity index 69% rename from tests/protocols/gmpv208/entities/users/test_get_users.py rename to tests/protocols/gmpv224/entities/users/test_get_users.py index 96e946b82..899285170 100644 --- a/tests/protocols/gmpv208/entities/users/test_get_users.py +++ b/tests/protocols/gmpv224/entities/users/test_get_users.py @@ -8,16 +8,16 @@ class GmpGetUsersTestMixin: def test_get_users(self): self.gmp.get_users() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_users_with_filter_string(self): self.gmp.get_users(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_users_with_filter_id(self): self.gmp.get_users(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv224/entities/users/test_modify_user.py b/tests/protocols/gmpv224/entities/users/test_modify_user.py index 4ff51b61c..f374b4b64 100644 --- a/tests/protocols/gmpv224/entities/users/test_modify_user.py +++ b/tests/protocols/gmpv224/entities/users/test_modify_user.py @@ -3,17 +3,17 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from unittest.mock import call, patch - from gvm.errors import RequiredArgument -from gvm.protocols.gmpv224 import UserAuthType +from gvm.protocols.gmp.requests.v224 import UserAuthType class GmpModifyUserTestMixin: def test_modify_user(self): self.gmp.modify_user(user_id="u1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) def test_modify_user_missing_user_id(self): with self.assertRaises(RequiredArgument): @@ -26,71 +26,75 @@ def test_modify_user_with_new_name(self): self.gmp.modify_user(user_id="u1", name="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_user_with_new_comment(self): self.gmp.modify_user(user_id="u1", comment="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_user_with_role_ids(self): self.gmp.modify_user(user_id="u1", role_ids=[]) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.modify_user(user_id="u1", role_ids=["r1"]) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.modify_user(user_id="u1", role_ids=["r1", "r2"]) self.connection.send.has_been_called_with( - '' - '' - '' - "" + b'' + b'' + b'' + b"" ) def test_modify_user_with_group_ids(self): self.gmp.modify_user(user_id="u1", role_ids=[]) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.modify_user(user_id="u1", group_ids=["r1"]) self.connection.send.has_been_called_with( - '' - '' - "" + b'' + b'' + b"" ) self.gmp.modify_user(user_id="u1", group_ids=["r1", "r2"]) self.connection.send.has_been_called_with( - '' - "" - '' - '' - "" - "" + b'' + b"" + b'' + b'' + b"" + b"" ) def test_modify_user_with_password(self): self.gmp.modify_user(user_id="u1", password="foo") self.connection.send.has_been_called_with( - '' - "foo" - "" + b'' + b"foo" + b"" ) def test_modify_user_with_auth_source(self): @@ -99,30 +103,32 @@ def test_modify_user_with_auth_source(self): ) self.connection.send.has_been_called_with( - '' - "ldap_connect" - "" + b'' + b"ldap_connect" + b"" ) def test_modify_user_with_hosts(self): self.gmp.modify_user(user_id="u1", hosts=[]) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.modify_user(user_id="u1", hosts=["foo"]) self.connection.send.has_been_called_with( - '' - 'foo' - "" + b'' + b'foo' + b"" ) self.gmp.modify_user(user_id="u1", hosts=["foo", "bar"]) self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" + b'' + b'foo,bar' + b"" ) self.gmp.modify_user( @@ -130,9 +136,9 @@ def test_modify_user_with_hosts(self): ) self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" + b'' + b'foo,bar' + b"" ) self.gmp.modify_user( @@ -140,49 +146,7 @@ def test_modify_user_with_hosts(self): ) self.connection.send.has_been_called_with( - '' - 'foo,bar' - "" + b'' + b'foo,bar' + b"" ) - - @patch("gvm.protocols.gmpv224.entities.users.deprecation") - def test_modify_user_with_ifaces(self, deprecation_mock): - self.gmp.modify_user(user_id="u1", ifaces=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u2", ifaces=["foo"]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u3", ifaces=["foo", "bar"]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user( - user_id="u4", ifaces=["foo", "bar"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user( - user_id="u5", ifaces=["foo", "bar"], ifaces_allow=True - ) - - self.connection.send.has_been_called_with('') - - # pylint: disable=line-too-long - deprecation_calls = [ - call("The ifaces parameter has been removed in GMP version 224"), - call("The ifaces parameter has been removed in GMP version 224"), - call("The ifaces parameter has been removed in GMP version 224"), - call( - "The ifaces_allow parameter has been removed in GMP version 224" - ), - call("The ifaces parameter has been removed in GMP version 224"), - call( - "The ifaces_allow parameter has been removed in GMP version 224" - ), - ] - # pylint: enable=line-too-long - deprecation_mock.assert_has_calls(deprecation_calls) diff --git a/tests/protocols/gmpv208/entities/vulnerabilities/__init__.py b/tests/protocols/gmpv224/entities/vulnerabilities/__init__.py similarity index 100% rename from tests/protocols/gmpv208/entities/vulnerabilities/__init__.py rename to tests/protocols/gmpv224/entities/vulnerabilities/__init__.py diff --git a/tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerabilities.py b/tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerabilities.py similarity index 72% rename from tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerabilities.py rename to tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerabilities.py index b986f48d9..c9dc64a40 100644 --- a/tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerabilities.py +++ b/tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerabilities.py @@ -8,16 +8,16 @@ class GmpGetVulnerabilitiesTestMixin: def test_get_vulnerabilities(self): self.gmp.get_vulnerabilities() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_vulnerabilities_with_filter_string(self): self.gmp.get_vulnerabilities(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_vulnerabilities_with_filter_id(self): self.gmp.get_vulnerabilities(filter_id="f1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') diff --git a/tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerability.py b/tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerability.py similarity index 79% rename from tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerability.py rename to tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerability.py index 6ab15089e..74e298559 100644 --- a/tests/protocols/gmpv208/entities/vulnerabilities/test_get_vulnerability.py +++ b/tests/protocols/gmpv224/entities/vulnerabilities/test_get_vulnerability.py @@ -10,11 +10,11 @@ class GmpGetVulnerabilityTestMixin: def test_get_vulnerability(self): self.gmp.get_vulnerability("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_vulnerability(vulnerability_id="a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_get_vulnerability_invalid_vulnerability_id(self): with self.assertRaises(RequiredArgument): diff --git a/tests/protocols/gmpv224/enums/test_aggregate_statistic.py b/tests/protocols/gmpv224/enums/test_aggregate_statistic.py index d84dc7676..25d07c952 100644 --- a/tests/protocols/gmpv224/enums/test_aggregate_statistic.py +++ b/tests/protocols/gmpv224/enums/test_aggregate_statistic.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv208 import AggregateStatistic +from gvm.protocols.gmp.requests.v224 import AggregateStatistic class GetAggregateStatisticFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_alert_condition.py b/tests/protocols/gmpv224/enums/test_alert_condition.py index 5e942ad0f..c83e91ee4 100644 --- a/tests/protocols/gmpv224/enums/test_alert_condition.py +++ b/tests/protocols/gmpv224/enums/test_alert_condition.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import AlertCondition +from gvm.protocols.gmp.requests.v224 import AlertCondition class GetAlertConditionFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_alert_event.py b/tests/protocols/gmpv224/enums/test_alert_event.py index bd7c03a30..f094ffac0 100644 --- a/tests/protocols/gmpv224/enums/test_alert_event.py +++ b/tests/protocols/gmpv224/enums/test_alert_event.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import AlertEvent +from gvm.protocols.gmp.requests.v224 import AlertEvent class GetAlertEventFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_alert_method.py b/tests/protocols/gmpv224/enums/test_alert_method.py index e66c973b8..4321edfc2 100644 --- a/tests/protocols/gmpv224/enums/test_alert_method.py +++ b/tests/protocols/gmpv224/enums/test_alert_method.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import AlertMethod +from gvm.protocols.gmp.requests.v224 import AlertMethod class GetAlertMethodFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_alive_test.py b/tests/protocols/gmpv224/enums/test_alive_test.py index d57a869dd..5dacfd03b 100644 --- a/tests/protocols/gmpv224/enums/test_alive_test.py +++ b/tests/protocols/gmpv224/enums/test_alive_test.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import AliveTest +from gvm.protocols.gmp.requests.v224 import AliveTest class GetAliveTestFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_credential_format.py b/tests/protocols/gmpv224/enums/test_credential_format.py index de9ecbe98..7a60f5be7 100644 --- a/tests/protocols/gmpv224/enums/test_credential_format.py +++ b/tests/protocols/gmpv224/enums/test_credential_format.py @@ -6,10 +6,10 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import CredentialFormat +from gvm.protocols.gmp.requests.v224 import CredentialFormat -class GetCredentialFromatFromStringTestCase(unittest.TestCase): +class GetCredentialFormatFromStringTestCase(unittest.TestCase): def test_invalid(self): with self.assertRaises(InvalidArgument): CredentialFormat.from_string("foo") diff --git a/tests/protocols/gmpv224/enums/test_credential_type.py b/tests/protocols/gmpv224/enums/test_credential_type.py index 4a63b4888..4643bbbd6 100644 --- a/tests/protocols/gmpv224/enums/test_credential_type.py +++ b/tests/protocols/gmpv224/enums/test_credential_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import CredentialType +from gvm.protocols.gmp.requests.v224 import CredentialType class GetCredentialTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_entity_type.py b/tests/protocols/gmpv224/enums/test_entity_type.py index 87219f793..8dd076b4e 100644 --- a/tests/protocols/gmpv224/enums/test_entity_type.py +++ b/tests/protocols/gmpv224/enums/test_entity_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import EntityType +from gvm.protocols.gmp.requests.v224 import EntityType class GetEntityTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_feed_type.py b/tests/protocols/gmpv224/enums/test_feed_type.py index ba067921d..575498db6 100644 --- a/tests/protocols/gmpv224/enums/test_feed_type.py +++ b/tests/protocols/gmpv224/enums/test_feed_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import FeedType +from gvm.protocols.gmp.requests.v224 import FeedType class GetFeedTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_filter_type.py b/tests/protocols/gmpv224/enums/test_filter_type.py index 71216cb13..bb7830b41 100644 --- a/tests/protocols/gmpv224/enums/test_filter_type.py +++ b/tests/protocols/gmpv224/enums/test_filter_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import FilterType +from gvm.protocols.gmp.requests.v224 import FilterType class GetFilterTypeFomStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_help_format.py b/tests/protocols/gmpv224/enums/test_help_format.py index 58103807a..287cc2ad5 100644 --- a/tests/protocols/gmpv224/enums/test_help_format.py +++ b/tests/protocols/gmpv224/enums/test_help_format.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import HelpFormat +from gvm.protocols.gmp.requests.v224 import HelpFormat class GetHelpFormatFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_hosts_ordering.py b/tests/protocols/gmpv224/enums/test_hosts_ordering.py index 2f54dec3d..127a95e7d 100644 --- a/tests/protocols/gmpv224/enums/test_hosts_ordering.py +++ b/tests/protocols/gmpv224/enums/test_hosts_ordering.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import HostsOrdering +from gvm.protocols.gmp.requests.v224 import HostsOrdering class GetHostsOrderingFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_info_type.py b/tests/protocols/gmpv224/enums/test_info_type.py index 57c643d75..b9facbe45 100644 --- a/tests/protocols/gmpv224/enums/test_info_type.py +++ b/tests/protocols/gmpv224/enums/test_info_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import InfoType +from gvm.protocols.gmp.requests.v224 import InfoType class GetInfoTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_permission_subject_type.py b/tests/protocols/gmpv224/enums/test_permission_subject_type.py index e1bdb1802..b1f7930d5 100644 --- a/tests/protocols/gmpv224/enums/test_permission_subject_type.py +++ b/tests/protocols/gmpv224/enums/test_permission_subject_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import PermissionSubjectType +from gvm.protocols.gmp.requests.v224 import PermissionSubjectType class GetPermissionSubjectTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_port_range_type.py b/tests/protocols/gmpv224/enums/test_port_range_type.py index c6741ae94..93fe6d24d 100644 --- a/tests/protocols/gmpv224/enums/test_port_range_type.py +++ b/tests/protocols/gmpv224/enums/test_port_range_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import PortRangeType +from gvm.protocols.gmp.requests.v224 import PortRangeType class GetPortRangeTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_report_format_type.py b/tests/protocols/gmpv224/enums/test_report_format_type.py index a4f95a96f..b1a6c3c53 100644 --- a/tests/protocols/gmpv224/enums/test_report_format_type.py +++ b/tests/protocols/gmpv224/enums/test_report_format_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import ReportFormatType +from gvm.protocols.gmp.requests.v224 import ReportFormatType class GetPortRangeTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_scanner_type.py b/tests/protocols/gmpv224/enums/test_scanner_type.py index dac182ae7..7e21f6232 100644 --- a/tests/protocols/gmpv224/enums/test_scanner_type.py +++ b/tests/protocols/gmpv224/enums/test_scanner_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import ScannerType +from gvm.protocols.gmp.requests.v224 import ScannerType class GetScannerTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_severity_level.py b/tests/protocols/gmpv224/enums/test_severity_level.py deleted file mode 100644 index 4acf58714..000000000 --- a/tests/protocols/gmpv224/enums/test_severity_level.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2020-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import SeverityLevel - - -class GetSeverityLevelFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SeverityLevel.from_string("foo") - - def test_none_or_empty(self): - ct = SeverityLevel.from_string(None) - self.assertIsNone(ct) - ct = SeverityLevel.from_string("") - self.assertIsNone(ct) - - def test_high(self): - ct = SeverityLevel.from_string("High") - self.assertEqual(ct, SeverityLevel.HIGH) - - def test_medium(self): - ct = SeverityLevel.from_string("Medium") - self.assertEqual(ct, SeverityLevel.MEDIUM) - - def test_low(self): - ct = SeverityLevel.from_string("Low") - self.assertEqual(ct, SeverityLevel.LOW) - - def test_log(self): - ct = SeverityLevel.from_string("Log") - self.assertEqual(ct, SeverityLevel.LOG) - - def test_alarm(self): - ct = SeverityLevel.from_string("Alarm") - self.assertEqual(ct, SeverityLevel.ALARM) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv224/enums/test_snmp_algorithms.py b/tests/protocols/gmpv224/enums/test_snmp_algorithms.py index 492c86013..9ab1e4a60 100644 --- a/tests/protocols/gmpv224/enums/test_snmp_algorithms.py +++ b/tests/protocols/gmpv224/enums/test_snmp_algorithms.py @@ -6,7 +6,10 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import SnmpAuthAlgorithm, SnmpPrivacyAlgorithm +from gvm.protocols.gmp.requests.v224 import ( + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, +) class GetSnmpAuthAlgorithmFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_sort_order.py b/tests/protocols/gmpv224/enums/test_sort_order.py index f6c4a077e..2ab6b86d0 100644 --- a/tests/protocols/gmpv224/enums/test_sort_order.py +++ b/tests/protocols/gmpv224/enums/test_sort_order.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import SortOrder +from gvm.protocols.gmp.requests.v224 import SortOrder class GetSortOrderFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_ticket_status.py b/tests/protocols/gmpv224/enums/test_ticket_status.py index f4c79f3ae..e9b068a7d 100644 --- a/tests/protocols/gmpv224/enums/test_ticket_status.py +++ b/tests/protocols/gmpv224/enums/test_ticket_status.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import TicketStatus +from gvm.protocols.gmp.requests.v224 import TicketStatus class GetTicketStatusFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv224/enums/test_user_auth_type.py b/tests/protocols/gmpv224/enums/test_user_auth_type.py index 67cfc5817..c5071e768 100644 --- a/tests/protocols/gmpv224/enums/test_user_auth_type.py +++ b/tests/protocols/gmpv224/enums/test_user_auth_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv224 import UserAuthType +from gvm.protocols.gmp.requests.v224 import UserAuthType class GetUserAuthTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv208/system/aggregates/__init__.py b/tests/protocols/gmpv224/system/aggregates/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/aggregates/__init__.py rename to tests/protocols/gmpv224/system/aggregates/__init__.py diff --git a/tests/protocols/gmpv208/system/aggregates/test_get_aggregates.py b/tests/protocols/gmpv224/system/aggregates/test_get_aggregates.py similarity index 72% rename from tests/protocols/gmpv208/system/aggregates/test_get_aggregates.py rename to tests/protocols/gmpv224/system/aggregates/test_get_aggregates.py index 9bc9813a5..89f5cb71e 100644 --- a/tests/protocols/gmpv208/system/aggregates/test_get_aggregates.py +++ b/tests/protocols/gmpv224/system/aggregates/test_get_aggregates.py @@ -4,7 +4,11 @@ # from gvm.errors import InvalidArgument, InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import AggregateStatistic, EntityType, SortOrder +from gvm.protocols.gmp.requests.v224 import ( + AggregateStatistic, + EntityType, + SortOrder, +) class GmpGetAggregatesTestMixin: @@ -16,77 +20,79 @@ def test_get_aggregates(self): self.gmp.get_aggregates(EntityType.ALERT) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(resource_type=EntityType.CERT_BUND_ADV) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.CPE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.CVE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.DFN_CERT_ADV) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.HOST) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.NOTE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.NVT) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.OPERATING_SYSTEM) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with( + b'' + ) self.gmp.get_aggregates(EntityType.OVALDEF) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.OVERRIDE) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.REPORT) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.RESULT) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_aggregates_resource_types_with_usage_type(self): @@ -97,25 +103,25 @@ def test_get_aggregates_resource_types_with_usage_type(self): self.gmp.get_aggregates(EntityType.AUDIT) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.POLICY) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.SCAN_CONFIG) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_aggregates(EntityType.TASK) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_aggregates_missing_resource_type(self): @@ -135,7 +141,7 @@ def test_get_aggregates_invalid_resource_type(self): """ Test get_aggregates calls with invalid resource_type """ - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_aggregates(resource_type="foo") def test_get_aggregates_sort_criteria(self): @@ -154,12 +160,12 @@ def test_get_aggregates_sort_criteria(self): ) self.connection.send.has_been_called_with( - '' - '' - '' - '' - "severity" - "" + b'' + b'' + b'' + b'' + b"severity" + b"" ) def test_get_aggregates_sort_criteria_enum(self): @@ -180,10 +186,10 @@ def test_get_aggregates_sort_criteria_enum(self): ) self.connection.send.has_been_called_with( - '' - '' - "severity" - "" + b'' + b'' + b"severity" + b"" ) def test_get_aggregates_invalid_sort_criteria(self): @@ -219,7 +225,7 @@ def test_get_aggregates_group_limits(self): self.gmp.get_aggregates(EntityType.CPE, first_group=20, max_groups=25) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_aggregates_invalid_group_limits(self): @@ -245,20 +251,21 @@ def test_get_aggregates_data_columns(self): ) self.connection.send.has_been_called_with( - '' - "severity" - "cves" - "" + b'' + b"severity" + b"cves" + b"" ) - def test_get_aggregates_invalid_data_columns(self): - """ - Test get_aggregates calls with invalid data_columns - """ - with self.assertRaises(InvalidArgumentType): - self.gmp.get_aggregates( - resource_type=EntityType.ALERT, data_columns="INVALID" - ) + self.gmp.get_aggregates( + resource_type=EntityType.ALERT, data_columns="severity" + ) + + self.connection.send.has_been_called_with( + b'' + b"severity" + b"" + ) def test_get_aggregates_group_column(self): """ @@ -267,7 +274,7 @@ def test_get_aggregates_group_column(self): self.gmp.get_aggregates(EntityType.NVT, group_column="family") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_aggregates_subgroup_column(self): @@ -281,8 +288,8 @@ def test_get_aggregates_subgroup_column(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_aggregates_missing_group_column(self): @@ -313,21 +320,25 @@ def test_get_aggregates_text_columns(self): ) self.connection.send.has_been_called_with( - '' - "name" - "comment" - "" + b'' + b"name" + b"comment" + b"" ) - def test_get_aggregates_invalid_text_columns(self): - """ - Test get_aggregates calls with invalid text_columns - """ - with self.assertRaises(InvalidArgumentType): - self.gmp.get_aggregates( - resource_type=EntityType.ALERT, text_columns="INVALID" - ) + self.gmp.get_aggregates( + EntityType.SCAN_CONFIG, + group_column="uuid", + text_columns="name", + ) + + self.connection.send.has_been_called_with( + b'' + b"name" + b"" + ) def test_get_aggregates_mode(self): """ @@ -338,6 +349,6 @@ def test_get_aggregates_mode(self): ) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/system/authentication/__init__.py b/tests/protocols/gmpv224/system/authentication/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/authentication/__init__.py rename to tests/protocols/gmpv224/system/authentication/__init__.py diff --git a/tests/protocols/gmpv208/system/authentication/test_authenticate.py b/tests/protocols/gmpv224/system/authentication/test_authenticate.py similarity index 71% rename from tests/protocols/gmpv208/system/authentication/test_authenticate.py rename to tests/protocols/gmpv224/system/authentication/test_authenticate.py index 00e387192..cb80987e6 100644 --- a/tests/protocols/gmpv208/system/authentication/test_authenticate.py +++ b/tests/protocols/gmpv224/system/authentication/test_authenticate.py @@ -27,19 +27,19 @@ def test_authentication_success(self): self.gmp.authenticate("foo", "bar") self.connection.send.has_been_called_with( - "" - "" - "foo" - "bar" - "" - "" + b"" + b"" + b"foo" + b"bar" + b"" + b"" ) self.assertTrue(self.gmp.is_authenticated()) def test_authentication_failure(self): self.connection.read.return_value( - '' + b'' ) self.assertFalse(self.gmp.is_authenticated()) @@ -47,12 +47,12 @@ def test_authentication_failure(self): self.gmp.authenticate("foo", "bar") self.connection.send.has_been_called_with( - "" - "" - "foo" - "bar" - "" - "" + b"" + b"" + b"foo" + b"bar" + b"" + b"" ) self.assertFalse(self.gmp.is_authenticated()) diff --git a/tests/protocols/gmpv208/system/authentication/test_describe_auth.py b/tests/protocols/gmpv224/system/authentication/test_describe_auth.py similarity index 73% rename from tests/protocols/gmpv208/system/authentication/test_describe_auth.py rename to tests/protocols/gmpv224/system/authentication/test_describe_auth.py index c690d39ae..80f2f917f 100644 --- a/tests/protocols/gmpv208/system/authentication/test_describe_auth.py +++ b/tests/protocols/gmpv224/system/authentication/test_describe_auth.py @@ -8,4 +8,4 @@ class GmpDescribeAuthTestMixin: def test_describe_auth(self): self.gmp.describe_auth() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") diff --git a/tests/protocols/gmpv208/system/authentication/test_modify_auth.py b/tests/protocols/gmpv224/system/authentication/test_modify_auth.py similarity index 78% rename from tests/protocols/gmpv208/system/authentication/test_modify_auth.py rename to tests/protocols/gmpv224/system/authentication/test_modify_auth.py index 29b4e249c..0fbdc564e 100644 --- a/tests/protocols/gmpv208/system/authentication/test_modify_auth.py +++ b/tests/protocols/gmpv224/system/authentication/test_modify_auth.py @@ -15,18 +15,18 @@ def test_modify_auth(self): ) self.connection.send.has_been_called_with( - "" - '' - "" - "foo" - "bar" - "" - "" - "lorem" - "ipsum" - "" - "" - "" + b"" + b'' + b"" + b"foo" + b"bar" + b"" + b"" + b"lorem" + b"ipsum" + b"" + b"" + b"" ) def test_modify_auth_missing_group_name(self): diff --git a/tests/protocols/gmpv208/system/feed/__init__.py b/tests/protocols/gmpv224/system/feed/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/feed/__init__.py rename to tests/protocols/gmpv224/system/feed/__init__.py diff --git a/tests/protocols/gmpv208/system/feed/test_get_feed.py b/tests/protocols/gmpv224/system/feed/test_get_feed.py similarity index 71% rename from tests/protocols/gmpv208/system/feed/test_get_feed.py rename to tests/protocols/gmpv224/system/feed/test_get_feed.py index 548e5a6e1..1dcca4bc1 100644 --- a/tests/protocols/gmpv208/system/feed/test_get_feed.py +++ b/tests/protocols/gmpv224/system/feed/test_get_feed.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv208 import FeedType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v224 import FeedType class GmpGetFeedTestMixin: @@ -15,20 +15,20 @@ def test_get_feed(self): """ self.gmp.get_feed(FeedType.NVT) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_feed(FeedType.CERT) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_feed(FeedType.SCAP) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') self.gmp.get_feed(FeedType.GVMD_DATA) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_feed_missing_type(self): @@ -48,5 +48,5 @@ def test_get_feed_invalid_type(self): """ Test get_feed calls with invalid resource_type """ - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_feed("foo") diff --git a/tests/protocols/gmpv208/system/feed/test_get_feeds.py b/tests/protocols/gmpv224/system/feed/test_get_feeds.py similarity index 73% rename from tests/protocols/gmpv208/system/feed/test_get_feeds.py rename to tests/protocols/gmpv224/system/feed/test_get_feeds.py index 40ffa9a00..f62c3f075 100644 --- a/tests/protocols/gmpv208/system/feed/test_get_feeds.py +++ b/tests/protocols/gmpv224/system/feed/test_get_feeds.py @@ -8,4 +8,4 @@ class GmpGetFeedsTestMixin: def test_get_feeds(self): self.gmp.get_feeds() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") diff --git a/tests/protocols/gmpv208/system/help/__init__.py b/tests/protocols/gmpv224/system/help/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/help/__init__.py rename to tests/protocols/gmpv224/system/help/__init__.py diff --git a/tests/protocols/gmpv208/system/help/test_help.py b/tests/protocols/gmpv224/system/help/test_help.py similarity index 58% rename from tests/protocols/gmpv208/system/help/test_help.py rename to tests/protocols/gmpv224/system/help/test_help.py index 518d638e6..893d4fa63 100644 --- a/tests/protocols/gmpv208/system/help/test_help.py +++ b/tests/protocols/gmpv224/system/help/test_help.py @@ -3,28 +3,28 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType -from gvm.protocols.gmpv208 import HelpFormat +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.v224 import HelpFormat class GmpHelpTestMixin: def test_help(self): self.gmp.help() - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_help_type_brief(self): self.gmp.help(brief=True) - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_invalid_help_format(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.help(help_format="foo") def test_html_format(self): self.gmp.help(help_format=HelpFormat.HTML) self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/system/system_reports/__init__.py b/tests/protocols/gmpv224/system/system_reports/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/system_reports/__init__.py rename to tests/protocols/gmpv224/system/system_reports/__init__.py diff --git a/tests/protocols/gmpv208/system/system_reports/test_get_system_reports.py b/tests/protocols/gmpv224/system/system_reports/test_get_system_reports.py similarity index 77% rename from tests/protocols/gmpv208/system/system_reports/test_get_system_reports.py rename to tests/protocols/gmpv224/system/system_reports/test_get_system_reports.py index 02ba3fe23..c4b535cce 100644 --- a/tests/protocols/gmpv208/system/system_reports/test_get_system_reports.py +++ b/tests/protocols/gmpv224/system/system_reports/test_get_system_reports.py @@ -10,40 +10,40 @@ class GmpGetSystemReportsTestMixin: def test_get_system_reports(self): self.gmp.get_system_reports() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_system_reports_with_name(self): self.gmp.get_system_reports(name="foo") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_system_reports_with_slave_id(self): self.gmp.get_system_reports(slave_id="s1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_system_reports_with_brief(self): self.gmp.get_system_reports(brief=True) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_system_reports(brief=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_system_reports_with_duration(self): self.gmp.get_system_reports(duration=3600) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_system_reports_with_invalid_duration(self): @@ -54,12 +54,12 @@ def test_get_system_reports_with_start_time(self): self.gmp.get_system_reports(start_time="01-01-2019") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_system_reports_with_end_time(self): self.gmp.get_system_reports(end_time="01-01-2019") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv224/system/test_aggregates.py b/tests/protocols/gmpv224/system/test_aggregates.py index cba0b1537..7b1ba7557 100644 --- a/tests/protocols/gmpv224/system/test_aggregates.py +++ b/tests/protocols/gmpv224/system/test_aggregates.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.aggregates import GmpGetAggregatesTestMixin from ...gmpv224 import Gmpv224TestCase +from .aggregates import GmpGetAggregatesTestMixin class Gmpv224GetAggregatesTestCase(GmpGetAggregatesTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/system/test_authentication.py b/tests/protocols/gmpv224/system/test_authentication.py index 6bd4dfa15..7457d3c12 100644 --- a/tests/protocols/gmpv224/system/test_authentication.py +++ b/tests/protocols/gmpv224/system/test_authentication.py @@ -3,12 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.authentication import ( +from ...gmpv224 import Gmpv224TestCase +from .authentication import ( GmpAuthenticateTestMixin, GmpDescribeAuthTestMixin, GmpModifyAuthTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224AuthenticateTestCase(GmpAuthenticateTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/system/test_feed.py b/tests/protocols/gmpv224/system/test_feed.py index 291580329..82268b931 100644 --- a/tests/protocols/gmpv224/system/test_feed.py +++ b/tests/protocols/gmpv224/system/test_feed.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin from ...gmpv224 import Gmpv224TestCase +from .feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin class Gmpv224GetFeedTestCase(GmpGetFeedTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/system/test_help.py b/tests/protocols/gmpv224/system/test_help.py index 729ba928d..dad47133a 100644 --- a/tests/protocols/gmpv224/system/test_help.py +++ b/tests/protocols/gmpv224/system/test_help.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.help import GmpHelpTestMixin from ...gmpv224 import Gmpv224TestCase +from .help import GmpHelpTestMixin class Gmpv224HelpTestCase(GmpHelpTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/system/test_system_reports.py b/tests/protocols/gmpv224/system/test_system_reports.py index 9b18b8902..425db34b6 100644 --- a/tests/protocols/gmpv224/system/test_system_reports.py +++ b/tests/protocols/gmpv224/system/test_system_reports.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.system_reports import GmpGetSystemReportsTestMixin from ...gmpv224 import Gmpv224TestCase +from .system_reports import GmpGetSystemReportsTestMixin class Gmpv224GetSystemReportsTestCase( diff --git a/tests/protocols/gmpv224/system/test_trashcan.py b/tests/protocols/gmpv224/system/test_trashcan.py index 136276185..024343e69 100644 --- a/tests/protocols/gmpv224/system/test_trashcan.py +++ b/tests/protocols/gmpv224/system/test_trashcan.py @@ -3,11 +3,11 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.trashcan import ( +from ...gmpv224 import Gmpv224TestCase +from .trashcan import ( GmpEmptyTrashcanTestMixin, GmpRestoreFromTrashcanTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224EmptyTrashcanTestCase(GmpEmptyTrashcanTestMixin, Gmpv224TestCase): diff --git a/tests/protocols/gmpv224/system/test_user_settings.py b/tests/protocols/gmpv224/system/test_user_settings.py index 0ef1af37c..6611e110a 100644 --- a/tests/protocols/gmpv224/system/test_user_settings.py +++ b/tests/protocols/gmpv224/system/test_user_settings.py @@ -3,12 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.user_settings import ( +from ...gmpv224 import Gmpv224TestCase +from .user_settings import ( GmpGetUserSettingsTestMixin, GmpGetUserSettingTestMixin, GmpModifyUserSettingTestMixin, ) -from ...gmpv224 import Gmpv224TestCase class Gmpv224GetUserSettingTestCase( diff --git a/tests/protocols/gmpv224/system/test_versions.py b/tests/protocols/gmpv224/system/test_versions.py index f6929be19..2de51c452 100644 --- a/tests/protocols/gmpv224/system/test_versions.py +++ b/tests/protocols/gmpv224/system/test_versions.py @@ -3,9 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.versions import GmpGetVersionTestCase from ...gmpv224 import Gmpv224TestCase -from .versions import GmpGetProtocolVersionTestCase +from .versions import GmpGetProtocolVersionTestCase, GmpGetVersionTestCase class Gmpv224GetVersionCommandTestCase(GmpGetVersionTestCase, Gmpv224TestCase): diff --git a/tests/protocols/gmpv208/system/trashcan/__init__.py b/tests/protocols/gmpv224/system/trashcan/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/trashcan/__init__.py rename to tests/protocols/gmpv224/system/trashcan/__init__.py diff --git a/tests/protocols/gmpv208/system/trashcan/test_empty_trashcan.py b/tests/protocols/gmpv224/system/trashcan/test_empty_trashcan.py similarity index 73% rename from tests/protocols/gmpv208/system/trashcan/test_empty_trashcan.py rename to tests/protocols/gmpv224/system/trashcan/test_empty_trashcan.py index f46f295f9..e8ccca420 100644 --- a/tests/protocols/gmpv208/system/trashcan/test_empty_trashcan.py +++ b/tests/protocols/gmpv224/system/trashcan/test_empty_trashcan.py @@ -8,4 +8,4 @@ class GmpEmptyTrashcanTestMixin: def test_empty_trashcan(self): self.gmp.empty_trashcan() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") diff --git a/tests/protocols/gmpv208/system/trashcan/test_restore_from_trashcan.py b/tests/protocols/gmpv224/system/trashcan/test_restore_from_trashcan.py similarity index 87% rename from tests/protocols/gmpv208/system/trashcan/test_restore_from_trashcan.py rename to tests/protocols/gmpv224/system/trashcan/test_restore_from_trashcan.py index b4eb0c380..af538717f 100644 --- a/tests/protocols/gmpv208/system/trashcan/test_restore_from_trashcan.py +++ b/tests/protocols/gmpv224/system/trashcan/test_restore_from_trashcan.py @@ -10,7 +10,7 @@ class GmpRestoreFromTrashcanTestMixin: def test_restore_from_trashcan(self): self.gmp.restore_from_trashcan("a1") - self.connection.send.has_been_called_with('') + self.connection.send.has_been_called_with(b'') def test_restore_from_trashcan_missing_id(self): with self.assertRaises(GvmError): diff --git a/tests/protocols/gmpv208/system/user_settings/__init__.py b/tests/protocols/gmpv224/system/user_settings/__init__.py similarity index 100% rename from tests/protocols/gmpv208/system/user_settings/__init__.py rename to tests/protocols/gmpv224/system/user_settings/__init__.py diff --git a/tests/protocols/gmpv208/system/user_settings/test_get_user_setting.py b/tests/protocols/gmpv224/system/user_settings/test_get_user_setting.py similarity index 92% rename from tests/protocols/gmpv208/system/user_settings/test_get_user_setting.py rename to tests/protocols/gmpv224/system/user_settings/test_get_user_setting.py index aa5c490a8..9ef33a418 100644 --- a/tests/protocols/gmpv208/system/user_settings/test_get_user_setting.py +++ b/tests/protocols/gmpv224/system/user_settings/test_get_user_setting.py @@ -11,7 +11,7 @@ def test_get_setting_simple(self): self.gmp.get_user_setting("id") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_setting_missing_setting_id(self): diff --git a/tests/protocols/gmpv208/system/user_settings/test_get_user_settings.py b/tests/protocols/gmpv224/system/user_settings/test_get_user_settings.py similarity index 76% rename from tests/protocols/gmpv208/system/user_settings/test_get_user_settings.py rename to tests/protocols/gmpv224/system/user_settings/test_get_user_settings.py index 1d86b6902..ee170c2e4 100644 --- a/tests/protocols/gmpv208/system/user_settings/test_get_user_settings.py +++ b/tests/protocols/gmpv224/system/user_settings/test_get_user_settings.py @@ -8,11 +8,11 @@ class GmpGetUserSettingsTestMixin: def test_get_settings(self): self.gmp.get_user_settings() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") def test_get_settings_with_filter_string(self): self.gmp.get_user_settings(filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv208/system/user_settings/test_modify_user_setting.py b/tests/protocols/gmpv224/system/user_settings/test_modify_user_setting.py similarity index 78% rename from tests/protocols/gmpv208/system/user_settings/test_modify_user_setting.py rename to tests/protocols/gmpv224/system/user_settings/test_modify_user_setting.py index b15c17456..d878faf5a 100644 --- a/tests/protocols/gmpv208/system/user_settings/test_modify_user_setting.py +++ b/tests/protocols/gmpv224/system/user_settings/test_modify_user_setting.py @@ -11,26 +11,26 @@ def test_modify_user_setting(self): self.gmp.modify_user_setting(setting_id="s1", value="bar") self.connection.send.has_been_called_with( - '' - "YmFy" - "" + b'' + b"YmFy" + b"" ) self.gmp.modify_user_setting(name="s1", value="bar") self.connection.send.has_been_called_with( - "" - "s1" - "YmFy" - "" + b"" + b"s1" + b"YmFy" + b"" ) self.gmp.modify_user_setting(setting_id="s1", value="") self.connection.send.has_been_called_with( - '' - "" - "" + b'' + b"" + b"" ) def test_modify_user_setting_missing_setting_id(self): diff --git a/tests/protocols/gmpv224/system/versions/__init__.py b/tests/protocols/gmpv224/system/versions/__init__.py index 90764e183..040a71783 100644 --- a/tests/protocols/gmpv224/system/versions/__init__.py +++ b/tests/protocols/gmpv224/system/versions/__init__.py @@ -4,5 +4,6 @@ # from .test_get_protocol_version import GmpGetProtocolVersionTestCase +from .test_get_version import GmpGetVersionTestCase -__all__ = ("GmpGetProtocolVersionTestCase",) +__all__ = ("GmpGetProtocolVersionTestCase", "GmpGetVersionTestCase") diff --git a/tests/protocols/gmpv208/system/versions/test_get_version.py b/tests/protocols/gmpv224/system/versions/test_get_version.py similarity index 82% rename from tests/protocols/gmpv208/system/versions/test_get_version.py rename to tests/protocols/gmpv224/system/versions/test_get_version.py index 92ff33480..a1b258f5f 100644 --- a/tests/protocols/gmpv208/system/versions/test_get_version.py +++ b/tests/protocols/gmpv224/system/versions/test_get_version.py @@ -11,4 +11,4 @@ def test_get_version(self): self.connection.connect.has_been_called() self.connection.read.has_been_called() self.connection.send.has_been_called() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") diff --git a/tests/protocols/gmpv224/test_gmp_types.py b/tests/protocols/gmpv224/test_gmp_types.py index f2033b389..00a436fe8 100644 --- a/tests/protocols/gmpv224/test_gmp_types.py +++ b/tests/protocols/gmpv224/test_gmp_types.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering +from gvm.protocols.gmp.requests.v224 import HostsOrdering from . import Gmpv224TestCase diff --git a/tests/protocols/gmpv225/__init__.py b/tests/protocols/gmpv225/__init__.py index baca74ef5..78f43d4df 100644 --- a/tests/protocols/gmpv225/__init__.py +++ b/tests/protocols/gmpv225/__init__.py @@ -4,10 +4,10 @@ # -from gvm.protocols.gmpv225 import Gmp +from gvm.protocols.gmp import GMPv225 from .. import GmpTestCase class Gmpv225TestCase(GmpTestCase): - gmp_class = Gmp + gmp_class = GMPv225 diff --git a/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_name.py b/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_name.py index 6d1aefadd..652e13f55 100644 --- a/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_name.py +++ b/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_name.py @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv225 import ResourceType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v225 import ResourceType class GmpGetResourceNameTestMixin: @@ -14,7 +14,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -22,7 +22,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -30,7 +30,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -38,7 +38,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -46,7 +46,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -54,7 +54,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -62,7 +62,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -70,7 +70,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -78,7 +78,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -86,7 +86,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -94,7 +94,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -102,7 +102,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -110,7 +110,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -118,7 +118,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -126,7 +126,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -134,7 +134,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -142,7 +142,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -150,7 +150,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -158,7 +158,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -166,7 +166,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -174,7 +174,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -182,7 +182,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -190,7 +190,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -198,7 +198,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) self.gmp.get_resource_name( @@ -206,7 +206,7 @@ def test_get_resource_name(self): ) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_resource_name_missing_resource_type(self): @@ -220,7 +220,7 @@ def test_get_resource_name_missing_resource_type(self): self.gmp.get_resource_name("i1", "") def test_get_resource_name_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): + with self.assertRaises(InvalidArgument): self.gmp.get_resource_name(resource_id="i1", resource_type="foo") def test_get_resource_name_missing_resource_id(self): diff --git a/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_names_list.py b/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_names_list.py index d2292c0f8..4caa15925 100644 --- a/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_names_list.py +++ b/tests/protocols/gmpv225/entities/resourcenames/test_get_resource_names_list.py @@ -3,192 +3,190 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.errors import InvalidArgumentType, RequiredArgument -from gvm.protocols.gmpv225 import ResourceType +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.v225 import ResourceType class GmpGetResourceNamesListTestMixin: - def test_get_resource_names_list(self): - self.gmp.get_resource_names_list(ResourceType.ALERT) + def test_get_resource_names(self): + self.gmp.get_resource_names(ResourceType.ALERT) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.CERT_BUND_ADV) + self.gmp.get_resource_names(ResourceType.CERT_BUND_ADV) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.CONFIG) + self.gmp.get_resource_names(ResourceType.CONFIG) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(resource_type=ResourceType.CPE) + self.gmp.get_resource_names(resource_type=ResourceType.CPE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.CREDENTIAL) + self.gmp.get_resource_names(ResourceType.CREDENTIAL) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.CVE) + self.gmp.get_resource_names(ResourceType.CVE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.DFN_CERT_ADV) + self.gmp.get_resource_names(ResourceType.DFN_CERT_ADV) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.FILTER) + self.gmp.get_resource_names(ResourceType.FILTER) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.GROUP) + self.gmp.get_resource_names(ResourceType.GROUP) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.HOST) + self.gmp.get_resource_names(ResourceType.HOST) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.NOTE) + self.gmp.get_resource_names(ResourceType.NOTE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.NVT) + self.gmp.get_resource_names(ResourceType.NVT) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.OS) + self.gmp.get_resource_names(ResourceType.OS) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.OVERRIDE) + self.gmp.get_resource_names(ResourceType.OVERRIDE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.PERMISSION) + self.gmp.get_resource_names(ResourceType.PERMISSION) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.PORT_LIST) + self.gmp.get_resource_names(ResourceType.PORT_LIST) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.REPORT_FORMAT) + self.gmp.get_resource_names(ResourceType.REPORT_FORMAT) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.REPORT) + self.gmp.get_resource_names(ResourceType.REPORT) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.RESULT) + self.gmp.get_resource_names(ResourceType.RESULT) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.ROLE) + self.gmp.get_resource_names(ResourceType.ROLE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.SCANNER) + self.gmp.get_resource_names(ResourceType.SCANNER) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.SCHEDULE) + self.gmp.get_resource_names(ResourceType.SCHEDULE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.TARGET) + self.gmp.get_resource_names(ResourceType.TARGET) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.TASK) + self.gmp.get_resource_names(ResourceType.TASK) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.TLS_CERTIFICATE) + self.gmp.get_resource_names(ResourceType.TLS_CERTIFICATE) self.connection.send.has_been_called_with( - '' + b'' ) - self.gmp.get_resource_names_list(ResourceType.USER) + self.gmp.get_resource_names(ResourceType.USER) self.connection.send.has_been_called_with( - '' + b'' ) with self.assertRaises(AttributeError): - self.gmp.get_resource_names_list( + self.gmp.get_resource_names( ResourceType.ALLRESOURCES # pylint: disable=no-member ) - def test_get_resource_names_list_missing_resource_type(self): + def test_get_resource_names_missing_resource_type(self): with self.assertRaises(RequiredArgument): - self.gmp.get_resource_names_list(resource_type=None) + self.gmp.get_resource_names(resource_type=None) with self.assertRaises(RequiredArgument): - self.gmp.get_resource_names_list(resource_type="") + self.gmp.get_resource_names(resource_type="") with self.assertRaises(RequiredArgument): - self.gmp.get_resource_names_list("") + self.gmp.get_resource_names("") - def test_get_resource_names_list_invalid_resource_type(self): - with self.assertRaises(InvalidArgumentType): - self.gmp.get_resource_names_list(resource_type="foo") + def test_get_resource_names_invalid_resource_type(self): + with self.assertRaises(InvalidArgument): + self.gmp.get_resource_names(resource_type="foo") - def test_get_resource_names_list_with_filter_string(self): - self.gmp.get_resource_names_list( - ResourceType.CPE, filter_string="foo=bar" - ) + def test_get_resource_names_with_filter_string(self): + self.gmp.get_resource_names(ResourceType.CPE, filter_string="foo=bar") self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/gmpv225/entities/test_alerts.py b/tests/protocols/gmpv225/entities/test_alerts.py index 2f0e272e7..65af4096c 100644 --- a/tests/protocols/gmpv225/entities/test_alerts.py +++ b/tests/protocols/gmpv225/entities/test_alerts.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.alerts import ( +from ...gmpv224.entities.alerts import ( GmpCloneAlertTestMixin, GmpCreateAlertTestMixin, GmpDeleteAlertTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_audits.py b/tests/protocols/gmpv225/entities/test_audits.py index a789ce204..3c994a9b2 100644 --- a/tests/protocols/gmpv225/entities/test_audits.py +++ b/tests/protocols/gmpv225/entities/test_audits.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.audits import ( +from ...gmpv224.entities.audits import ( GmpCloneAuditTestMixin, GmpCreateAuditTestMixin, GmpDeleteAuditTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_credentials.py b/tests/protocols/gmpv225/entities/test_credentials.py index a579649f3..67b02b897 100644 --- a/tests/protocols/gmpv225/entities/test_credentials.py +++ b/tests/protocols/gmpv225/entities/test_credentials.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.credentials import ( +from ...gmpv224.entities.credentials import ( GmpCloneCredentialTestMixin, GmpCreateCredentialTestMixin, GmpDeleteCredentialTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_filters.py b/tests/protocols/gmpv225/entities/test_filters.py index 5cbf3e1fd..6f1e7a7db 100644 --- a/tests/protocols/gmpv225/entities/test_filters.py +++ b/tests/protocols/gmpv225/entities/test_filters.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.filters import ( +from ...gmpv224.entities.filters import ( GmpCloneFilterTestMixin, GmpCreateFilterTestMixin, GmpDeleteFilterTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_groups.py b/tests/protocols/gmpv225/entities/test_groups.py index b63c3245f..0dadc6a31 100644 --- a/tests/protocols/gmpv225/entities/test_groups.py +++ b/tests/protocols/gmpv225/entities/test_groups.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.groups import ( +from ...gmpv224.entities.groups import ( GmpCloneGroupTestMixin, GmpCreateGroupTestMixin, GmpDeleteGroupTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_hosts.py b/tests/protocols/gmpv225/entities/test_hosts.py index 262d4c3a8..aeeb0813a 100644 --- a/tests/protocols/gmpv225/entities/test_hosts.py +++ b/tests/protocols/gmpv225/entities/test_hosts.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.hosts import ( +from ...gmpv224.entities.hosts import ( GmpCreateHostTestMixin, GmpDeleteHostTestMixin, GmpGetHostsTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_notes.py b/tests/protocols/gmpv225/entities/test_notes.py index 2f2e0dd4b..119b15800 100644 --- a/tests/protocols/gmpv225/entities/test_notes.py +++ b/tests/protocols/gmpv225/entities/test_notes.py @@ -3,14 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.notes import ( +from ...gmpv224.entities.notes import ( GmpCloneNoteTestMixin, + GmpCreateNoteTestMixin, GmpDeleteNoteTestMixin, GmpGetNotesTestMixin, GmpGetNoteTestMixin, -) -from ...gmpv224.entities.notes import ( - GmpCreateNoteTestMixin, GmpModifyNoteTestMixin, ) from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/entities/test_operating_systems.py b/tests/protocols/gmpv225/entities/test_operating_systems.py index c601eeecf..5852988b1 100644 --- a/tests/protocols/gmpv225/entities/test_operating_systems.py +++ b/tests/protocols/gmpv225/entities/test_operating_systems.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.operating_systems import ( +from ...gmpv224.entities.operating_systems import ( GmpDeleteOperatingSystemTestMixin, GmpGetOperatingSystemsTestMixin, GmpGetOperatingSystemTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_overrides.py b/tests/protocols/gmpv225/entities/test_overrides.py index 612ddb1e1..1077ff59a 100644 --- a/tests/protocols/gmpv225/entities/test_overrides.py +++ b/tests/protocols/gmpv225/entities/test_overrides.py @@ -3,14 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.overrides import ( +from ...gmpv224.entities.overrides import ( GmpCloneOverrideTestMixin, + GmpCreateOverrideTestMixin, GmpDeleteOverrideTestMixin, GmpGetOverridesTestMixin, GmpGetOverrideTestMixin, -) -from ...gmpv224.entities.overrides import ( - GmpCreateOverrideTestMixin, GmpModifyOverrideTestMixin, ) from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/entities/test_permissions.py b/tests/protocols/gmpv225/entities/test_permissions.py index 798c7449b..3f73595cc 100644 --- a/tests/protocols/gmpv225/entities/test_permissions.py +++ b/tests/protocols/gmpv225/entities/test_permissions.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.permissions import ( +from ...gmpv224.entities.permissions import ( GmpClonePermissionTestMixin, GmpCreatePermissionTestMixin, GmpDeletePermissionTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_policies.py b/tests/protocols/gmpv225/entities/test_policies.py index a75f9d0cd..ac0d460fa 100644 --- a/tests/protocols/gmpv225/entities/test_policies.py +++ b/tests/protocols/gmpv225/entities/test_policies.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.policies import ( +from ...gmpv224.entities.policies import ( GmpClonePolicyTestMixin, GmpCreatePolicyTestMixin, GmpDeletePolicyTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_port_lists.py b/tests/protocols/gmpv225/entities/test_port_lists.py index 5c3d615c5..2e3d06c30 100644 --- a/tests/protocols/gmpv225/entities/test_port_lists.py +++ b/tests/protocols/gmpv225/entities/test_port_lists.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.port_lists import ( +from ...gmpv224.entities.port_lists import ( GmpClonePortListTestMixin, GmpCreatePortListTestMixin, GmpCreatePortRangeTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_report_formats.py b/tests/protocols/gmpv225/entities/test_report_formats.py index ce96d3d67..ba5803f21 100644 --- a/tests/protocols/gmpv225/entities/test_report_formats.py +++ b/tests/protocols/gmpv225/entities/test_report_formats.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.report_formats import ( +from ...gmpv224.entities.report_formats import ( GmpCloneReportFormatTestMixin, GmpDeleteReportFormatTestMixin, GmpGetReportFormatsTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_reports.py b/tests/protocols/gmpv225/entities/test_reports.py index 47c24ffe3..60d645f26 100644 --- a/tests/protocols/gmpv225/entities/test_reports.py +++ b/tests/protocols/gmpv225/entities/test_reports.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.reports import ( +from ...gmpv224.entities.reports import ( GmpDeleteReportTestMixin, GmpGetReportsTestMixin, GmpGetReportTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_results.py b/tests/protocols/gmpv225/entities/test_results.py index 4d762ba18..9e88cf12d 100644 --- a/tests/protocols/gmpv225/entities/test_results.py +++ b/tests/protocols/gmpv225/entities/test_results.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.results import ( +from ...gmpv224.entities.results import ( GmpGetResultsTestMixin, GmpGetResultTestMixin, ) diff --git a/tests/protocols/gmpv225/entities/test_roles.py b/tests/protocols/gmpv225/entities/test_roles.py index c42e1c3d4..0dda8438b 100644 --- a/tests/protocols/gmpv225/entities/test_roles.py +++ b/tests/protocols/gmpv225/entities/test_roles.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.roles import ( +from ...gmpv224.entities.roles import ( GmpCloneRoleTestMixin, GmpCreateRoleTestMixin, GmpDeleteRoleTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_scan_configs.py b/tests/protocols/gmpv225/entities/test_scan_configs.py index 87b453324..3d0e6aa49 100644 --- a/tests/protocols/gmpv225/entities/test_scan_configs.py +++ b/tests/protocols/gmpv225/entities/test_scan_configs.py @@ -16,7 +16,6 @@ GmpModifyScanConfigSetNvtPreferenceTestMixin, GmpModifyScanConfigSetNvtSelectionTestMixin, GmpModifyScanConfigSetScannerPreferenceTestMixin, - GmpModifyScanConfigTestMixin, ) from ...gmpv225 import Gmpv225TestCase @@ -89,9 +88,3 @@ class Gmpv225ModifyScanConfigSetScannerPreferenceTestCase( GmpModifyScanConfigSetScannerPreferenceTestMixin, Gmpv225TestCase ): pass - - -class Gmpv225ModifyScanConfigTestCase( - GmpModifyScanConfigTestMixin, Gmpv225TestCase -): - pass diff --git a/tests/protocols/gmpv225/entities/test_scanners.py b/tests/protocols/gmpv225/entities/test_scanners.py index fce62de59..7632f8ec3 100644 --- a/tests/protocols/gmpv225/entities/test_scanners.py +++ b/tests/protocols/gmpv225/entities/test_scanners.py @@ -3,14 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.scanners import ( +from ...gmpv224.entities.scanners import ( GmpCloneScannerTestMixin, + GmpCreateScannerTestMixin, GmpDeleteScannerTestMixin, GmpGetScannersTestMixin, GmpGetScannerTestMixin, -) -from ...gmpv224.entities.scanners import ( - GmpCreateScannerTestMixin, GmpModifyScannerTestMixin, ) from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/entities/test_schedules.py b/tests/protocols/gmpv225/entities/test_schedules.py index dac6c584a..4b42b528a 100644 --- a/tests/protocols/gmpv225/entities/test_schedules.py +++ b/tests/protocols/gmpv225/entities/test_schedules.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.schedules import ( +from ...gmpv224.entities.schedules import ( GmpCloneScheduleTestMixin, GmpCreateScheduleTestMixin, GmpDeleteScheduleTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_secinfo.py b/tests/protocols/gmpv225/entities/test_secinfo.py index 0e241f728..2084d01f4 100644 --- a/tests/protocols/gmpv225/entities/test_secinfo.py +++ b/tests/protocols/gmpv225/entities/test_secinfo.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.secinfo import ( +from ...gmpv224.entities.secinfo import ( GmpGetCertBundListTestMixin, GmpGetCertBundTestMixin, GmpGetCpeListTestMixin, @@ -17,8 +17,6 @@ GmpGetNvtFamiliesTestMixin, GmpGetNvtListTestMixin, GmpGetNvtTestMixin, - GmpGetOvalDefListTestMixin, - GmpGetOvalDefTestMixin, GmpGetScanConfigNvtsTestMixin, GmpGetScanConfigNvtTestMixin, ) @@ -41,10 +39,6 @@ class Gmpv225GetDfnCertCase(GmpGetDfnCertTestMixin, Gmpv225TestCase): pass -class Gmpv225GetOvalDefCase(GmpGetOvalDefTestMixin, Gmpv225TestCase): - pass - - class Gmpv225GetInfoListTestCase(GmpGetInfoListTestMixin, Gmpv225TestCase): pass @@ -95,9 +89,3 @@ class Gmpv225GetDfnCertListCase(GmpGetDfnCertListTestMixin, Gmpv225TestCase): class Gmpv225GetNvtListTestCase(GmpGetNvtListTestMixin, Gmpv225TestCase): pass - - -class Gmpv225GetOvalDefListTestCase( - GmpGetOvalDefListTestMixin, Gmpv225TestCase -): - pass diff --git a/tests/protocols/gmpv225/entities/test_tags.py b/tests/protocols/gmpv225/entities/test_tags.py index 63f6c3611..7e9258382 100644 --- a/tests/protocols/gmpv225/entities/test_tags.py +++ b/tests/protocols/gmpv225/entities/test_tags.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tags import ( +from ...gmpv224.entities.tags import ( GmpCloneTagTestMixin, GmpCreateTagTestMixin, GmpDeleteTagTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_targets.py b/tests/protocols/gmpv225/entities/test_targets.py index f71d01a3e..c41413e89 100644 --- a/tests/protocols/gmpv225/entities/test_targets.py +++ b/tests/protocols/gmpv225/entities/test_targets.py @@ -3,14 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.targets import ( +from ...gmpv224.entities.targets import ( GmpCloneTargetTestMixin, + GmpCreateTargetTestMixin, GmpDeleteTargetTestMixin, GmpGetTargetsTestMixin, GmpGetTargetTestMixin, -) -from ...gmpv224.entities.targets import ( - GmpCreateTargetTestMixin, GmpModifyTargetTestMixin, ) from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/entities/test_tasks.py b/tests/protocols/gmpv225/entities/test_tasks.py index e7f9886a2..910535561 100644 --- a/tests/protocols/gmpv225/entities/test_tasks.py +++ b/tests/protocols/gmpv225/entities/test_tasks.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tasks import ( +from ...gmpv224.entities.tasks import ( GmpCloneTaskTestMixin, GmpCreateContainerTaskTestMixin, GmpCreateTaskTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_tickets.py b/tests/protocols/gmpv225/entities/test_tickets.py index 8f2c8544d..42ee86307 100644 --- a/tests/protocols/gmpv225/entities/test_tickets.py +++ b/tests/protocols/gmpv225/entities/test_tickets.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tickets import ( +from ...gmpv224.entities.tickets import ( GmpCloneTicketTestMixin, GmpCreateTicketTestMixin, GmpDeleteTicketTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_tls_certificates.py b/tests/protocols/gmpv225/entities/test_tls_certificates.py index 592f7f8ea..244adec1e 100644 --- a/tests/protocols/gmpv225/entities/test_tls_certificates.py +++ b/tests/protocols/gmpv225/entities/test_tls_certificates.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.tls_certificates import ( +from ...gmpv224.entities.tls_certificates import ( GmpCloneTLSCertificateTestMixin, GmpCreateTLSCertificateTestMixin, GmpDeleteTLSCertificateTestMixin, diff --git a/tests/protocols/gmpv225/entities/test_users.py b/tests/protocols/gmpv225/entities/test_users.py index df0b4b33b..011c31609 100644 --- a/tests/protocols/gmpv225/entities/test_users.py +++ b/tests/protocols/gmpv225/entities/test_users.py @@ -3,16 +3,12 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from unittest.mock import call, patch - -from ...gmpv208.entities.users import ( +from ...gmpv224.entities.users import ( GmpCloneUserTestMixin, + GmpCreateUserTestMixin, GmpDeleteUserTestMixin, GmpGetUsersTestMixin, GmpGetUserTestMixin, -) -from ...gmpv224.entities.users import ( - GmpCreateUserTestMixin, GmpModifyUserTestMixin, ) from ...gmpv225 import Gmpv225TestCase @@ -23,42 +19,7 @@ class Gmpv225CloneUserTestCase(GmpCloneUserTestMixin, Gmpv225TestCase): class Gmpv225CreateUserTestCase(GmpCreateUserTestMixin, Gmpv225TestCase): - @patch("gvm.protocols.gmpv224.entities.users.deprecation") - def test_create_user_with_ifaces(self, deprecation_mock): - self.gmp.create_user(name="foo", ifaces=["h1", "h2"], ifaces_allow=True) - - self.connection.send.has_been_called_with( - "foo" - ) - - self.gmp.create_user(name="foo", ifaces=["h1", "h2"]) - - self.connection.send.has_been_called_with( - "foo" - ) - - self.gmp.create_user( - name="foo", ifaces=["h1", "h2"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with( - "foo" - ) - - # pylint: disable=line-too-long - deprecation_calls = [ - call("The ifaces parameter has been removed in GMP version 225"), - call( - "The ifaces_allow parameter has been removed in GMP version 225" - ), - call("The ifaces parameter has been removed in GMP version 225"), - call("The ifaces parameter has been removed in GMP version 225"), - call( - "The ifaces_allow parameter has been removed in GMP version 225" - ), - ] - # pylint: enable=line-too-long - deprecation_mock.assert_has_calls(deprecation_calls) + pass class Gmpv225DeleteUserTestCase(GmpDeleteUserTestMixin, Gmpv225TestCase): @@ -74,44 +35,4 @@ class Gmpv225GetUsersTestCase(GmpGetUsersTestMixin, Gmpv225TestCase): class Gmpv225ModifyUserTestCase(GmpModifyUserTestMixin, Gmpv225TestCase): - @patch("gvm.protocols.gmpv224.entities.users.deprecation") - def test_modify_user_with_ifaces(self, deprecation_mock): - self.gmp.modify_user(user_id="u1", ifaces=[]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u2", ifaces=["foo"]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user(user_id="u3", ifaces=["foo", "bar"]) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user( - user_id="u4", ifaces=["foo", "bar"], ifaces_allow=False - ) - - self.connection.send.has_been_called_with('') - - self.gmp.modify_user( - user_id="u5", ifaces=["foo", "bar"], ifaces_allow=True - ) - - self.connection.send.has_been_called_with('') - - # pylint: disable=line-too-long - deprecation_calls = [ - call("The ifaces parameter has been removed in GMP version 225"), - call("The ifaces parameter has been removed in GMP version 225"), - call("The ifaces parameter has been removed in GMP version 225"), - call( - "The ifaces_allow parameter has been removed in GMP version 225" - ), - call("The ifaces parameter has been removed in GMP version 225"), - call( - "The ifaces_allow parameter has been removed in GMP version 225" - ), - ] - # pylint: enable=line-too-long - deprecation_mock.assert_has_calls(deprecation_calls) + pass diff --git a/tests/protocols/gmpv225/entities/test_vulnerabilities.py b/tests/protocols/gmpv225/entities/test_vulnerabilities.py index c54cbf400..c9a70a4cf 100644 --- a/tests/protocols/gmpv225/entities/test_vulnerabilities.py +++ b/tests/protocols/gmpv225/entities/test_vulnerabilities.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.entities.vulnerabilities import ( +from ...gmpv224.entities.vulnerabilities import ( GmpGetVulnerabilitiesTestMixin, GmpGetVulnerabilityTestMixin, ) diff --git a/tests/protocols/gmpv225/enums/test_aggregate_statistic.py b/tests/protocols/gmpv225/enums/test_aggregate_statistic.py index 00591495b..ea083f02b 100644 --- a/tests/protocols/gmpv225/enums/test_aggregate_statistic.py +++ b/tests/protocols/gmpv225/enums/test_aggregate_statistic.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import AggregateStatistic +from gvm.protocols.gmp.requests.v225 import AggregateStatistic class GetAggregateStatisticFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_alert_condition.py b/tests/protocols/gmpv225/enums/test_alert_condition.py index c9dde9f00..0f3049a20 100644 --- a/tests/protocols/gmpv225/enums/test_alert_condition.py +++ b/tests/protocols/gmpv225/enums/test_alert_condition.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import AlertCondition +from gvm.protocols.gmp.requests.v225 import AlertCondition class GetAlertConditionFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_alert_event.py b/tests/protocols/gmpv225/enums/test_alert_event.py index c2797096e..baee4ccbc 100644 --- a/tests/protocols/gmpv225/enums/test_alert_event.py +++ b/tests/protocols/gmpv225/enums/test_alert_event.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import AlertEvent +from gvm.protocols.gmp.requests.v225 import AlertEvent class GetAlertEventFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_alert_method.py b/tests/protocols/gmpv225/enums/test_alert_method.py index 57bf56483..a8991f121 100644 --- a/tests/protocols/gmpv225/enums/test_alert_method.py +++ b/tests/protocols/gmpv225/enums/test_alert_method.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import AlertMethod +from gvm.protocols.gmp.requests.v225 import AlertMethod class GetAlertMethodFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_alive_test.py b/tests/protocols/gmpv225/enums/test_alive_test.py index abc790738..40bc14630 100644 --- a/tests/protocols/gmpv225/enums/test_alive_test.py +++ b/tests/protocols/gmpv225/enums/test_alive_test.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import AliveTest +from gvm.protocols.gmp.requests.v225 import AliveTest class GetAliveTestFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_credential_format.py b/tests/protocols/gmpv225/enums/test_credential_format.py index 632a65906..4328ff3cc 100644 --- a/tests/protocols/gmpv225/enums/test_credential_format.py +++ b/tests/protocols/gmpv225/enums/test_credential_format.py @@ -6,10 +6,10 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import CredentialFormat +from gvm.protocols.gmp.requests.v225 import CredentialFormat -class GetCredentialFromatFromStringTestCase(unittest.TestCase): +class GetCredentialFormatFromStringTestCase(unittest.TestCase): def test_invalid(self): with self.assertRaises(InvalidArgument): CredentialFormat.from_string("foo") diff --git a/tests/protocols/gmpv225/enums/test_credential_type.py b/tests/protocols/gmpv225/enums/test_credential_type.py index 55916e489..5a62feacc 100644 --- a/tests/protocols/gmpv225/enums/test_credential_type.py +++ b/tests/protocols/gmpv225/enums/test_credential_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import CredentialType +from gvm.protocols.gmp.requests.v225 import CredentialType class GetCredentialTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_entity_type.py b/tests/protocols/gmpv225/enums/test_entity_type.py index e821c5c81..3996def95 100644 --- a/tests/protocols/gmpv225/enums/test_entity_type.py +++ b/tests/protocols/gmpv225/enums/test_entity_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import EntityType +from gvm.protocols.gmp.requests.v225 import EntityType class GetEntityTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_feed_type.py b/tests/protocols/gmpv225/enums/test_feed_type.py index 7c99a39bb..ba3f455a0 100644 --- a/tests/protocols/gmpv225/enums/test_feed_type.py +++ b/tests/protocols/gmpv225/enums/test_feed_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import FeedType +from gvm.protocols.gmp.requests.v225 import FeedType class GetFeedTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_filter_type.py b/tests/protocols/gmpv225/enums/test_filter_type.py index 7d396d6c7..360c25cf5 100644 --- a/tests/protocols/gmpv225/enums/test_filter_type.py +++ b/tests/protocols/gmpv225/enums/test_filter_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import FilterType +from gvm.protocols.gmp.requests.v225 import FilterType class GetFilterTypeFomStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_help_format.py b/tests/protocols/gmpv225/enums/test_help_format.py index ef893887e..8a2803746 100644 --- a/tests/protocols/gmpv225/enums/test_help_format.py +++ b/tests/protocols/gmpv225/enums/test_help_format.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import HelpFormat +from gvm.protocols.gmp.requests.v225 import HelpFormat class GetHelpFormatFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_hosts_ordering.py b/tests/protocols/gmpv225/enums/test_hosts_ordering.py index b551a266c..d5f9eaaa6 100644 --- a/tests/protocols/gmpv225/enums/test_hosts_ordering.py +++ b/tests/protocols/gmpv225/enums/test_hosts_ordering.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import HostsOrdering +from gvm.protocols.gmp.requests.v225 import HostsOrdering class GetHostsOrderingFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_info_type copy.py b/tests/protocols/gmpv225/enums/test_info_type.py similarity index 96% rename from tests/protocols/gmpv225/enums/test_info_type copy.py rename to tests/protocols/gmpv225/enums/test_info_type.py index 17b138579..2dd6c76d4 100644 --- a/tests/protocols/gmpv225/enums/test_info_type copy.py +++ b/tests/protocols/gmpv225/enums/test_info_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import InfoType +from gvm.protocols.gmp.requests.v225 import InfoType class GetInfoTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_permission_subject_type.py b/tests/protocols/gmpv225/enums/test_permission_subject_type.py index 221728cd8..0907571d9 100644 --- a/tests/protocols/gmpv225/enums/test_permission_subject_type.py +++ b/tests/protocols/gmpv225/enums/test_permission_subject_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import PermissionSubjectType +from gvm.protocols.gmp.requests.v225 import PermissionSubjectType class GetPermissionSubjectTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_port_range_type.py b/tests/protocols/gmpv225/enums/test_port_range_type.py index b99b4ca20..09c515948 100644 --- a/tests/protocols/gmpv225/enums/test_port_range_type.py +++ b/tests/protocols/gmpv225/enums/test_port_range_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import PortRangeType +from gvm.protocols.gmp.requests.v225 import PortRangeType class GetPortRangeTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_report_format_type.py b/tests/protocols/gmpv225/enums/test_report_format_type.py index 209a34250..828d481e3 100644 --- a/tests/protocols/gmpv225/enums/test_report_format_type.py +++ b/tests/protocols/gmpv225/enums/test_report_format_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import ReportFormatType +from gvm.protocols.gmp.requests.v225 import ReportFormatType class GetPortRangeTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_resource_type.py b/tests/protocols/gmpv225/enums/test_resource_type.py index 7e566a3df..d3ad668a3 100644 --- a/tests/protocols/gmpv225/enums/test_resource_type.py +++ b/tests/protocols/gmpv225/enums/test_resource_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import ResourceType +from gvm.protocols.gmp.requests.v225 import ResourceType class GetResourceTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_scanner_type.py b/tests/protocols/gmpv225/enums/test_scanner_type.py index 63bb392d9..804dfccc4 100644 --- a/tests/protocols/gmpv225/enums/test_scanner_type.py +++ b/tests/protocols/gmpv225/enums/test_scanner_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import ScannerType +from gvm.protocols.gmp.requests.v225 import ScannerType class GetScannerTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_severity_level.py b/tests/protocols/gmpv225/enums/test_severity_level.py deleted file mode 100644 index de598f0b0..000000000 --- a/tests/protocols/gmpv225/enums/test_severity_level.py +++ /dev/null @@ -1,45 +0,0 @@ -# SPDX-FileCopyrightText: 2023-2024 Greenbone AG -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -import unittest - -from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import SeverityLevel - - -class GetSeverityLevelFromStringTestCase(unittest.TestCase): - def test_invalid(self): - with self.assertRaises(InvalidArgument): - SeverityLevel.from_string("foo") - - def test_none_or_empty(self): - ct = SeverityLevel.from_string(None) - self.assertIsNone(ct) - ct = SeverityLevel.from_string("") - self.assertIsNone(ct) - - def test_high(self): - ct = SeverityLevel.from_string("High") - self.assertEqual(ct, SeverityLevel.HIGH) - - def test_medium(self): - ct = SeverityLevel.from_string("Medium") - self.assertEqual(ct, SeverityLevel.MEDIUM) - - def test_low(self): - ct = SeverityLevel.from_string("Low") - self.assertEqual(ct, SeverityLevel.LOW) - - def test_log(self): - ct = SeverityLevel.from_string("Log") - self.assertEqual(ct, SeverityLevel.LOG) - - def test_alarm(self): - ct = SeverityLevel.from_string("Alarm") - self.assertEqual(ct, SeverityLevel.ALARM) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/protocols/gmpv225/enums/test_snmp_algorithms.py b/tests/protocols/gmpv225/enums/test_snmp_algorithms.py index 2f7547726..7d1dc79c7 100644 --- a/tests/protocols/gmpv225/enums/test_snmp_algorithms.py +++ b/tests/protocols/gmpv225/enums/test_snmp_algorithms.py @@ -6,7 +6,10 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import SnmpAuthAlgorithm, SnmpPrivacyAlgorithm +from gvm.protocols.gmp.requests.v225 import ( + SnmpAuthAlgorithm, + SnmpPrivacyAlgorithm, +) class GetSnmpAuthAlgorithmFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_sort_order.py b/tests/protocols/gmpv225/enums/test_sort_order.py index 8aadfa150..1c646ec21 100644 --- a/tests/protocols/gmpv225/enums/test_sort_order.py +++ b/tests/protocols/gmpv225/enums/test_sort_order.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import SortOrder +from gvm.protocols.gmp.requests.v225 import SortOrder class GetSortOrderFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_ticket_status.py b/tests/protocols/gmpv225/enums/test_ticket_status.py index ce22e9899..62e507c4b 100644 --- a/tests/protocols/gmpv225/enums/test_ticket_status.py +++ b/tests/protocols/gmpv225/enums/test_ticket_status.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import TicketStatus +from gvm.protocols.gmp.requests.v225 import TicketStatus class GetTicketStatusFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/enums/test_user_auth_type.py b/tests/protocols/gmpv225/enums/test_user_auth_type.py index 813ed5975..75f8f6d4f 100644 --- a/tests/protocols/gmpv225/enums/test_user_auth_type.py +++ b/tests/protocols/gmpv225/enums/test_user_auth_type.py @@ -6,7 +6,7 @@ import unittest from gvm.errors import InvalidArgument -from gvm.protocols.gmpv225 import UserAuthType +from gvm.protocols.gmp.requests.v225 import UserAuthType class GetUserAuthTypeFromStringTestCase(unittest.TestCase): diff --git a/tests/protocols/gmpv225/system/test_aggregates.py b/tests/protocols/gmpv225/system/test_aggregates.py index 396cc3615..902461275 100644 --- a/tests/protocols/gmpv225/system/test_aggregates.py +++ b/tests/protocols/gmpv225/system/test_aggregates.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.aggregates import GmpGetAggregatesTestMixin +from ...gmpv224.system.aggregates import GmpGetAggregatesTestMixin from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/system/test_authentication.py b/tests/protocols/gmpv225/system/test_authentication.py index 4eff004bb..ce6616ec8 100644 --- a/tests/protocols/gmpv225/system/test_authentication.py +++ b/tests/protocols/gmpv225/system/test_authentication.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.authentication import ( +from ...gmpv224.system.authentication import ( GmpAuthenticateTestMixin, GmpDescribeAuthTestMixin, GmpModifyAuthTestMixin, diff --git a/tests/protocols/gmpv225/system/test_feed.py b/tests/protocols/gmpv225/system/test_feed.py index 1e75c26be..7149816f8 100644 --- a/tests/protocols/gmpv225/system/test_feed.py +++ b/tests/protocols/gmpv225/system/test_feed.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin +from ...gmpv224.system.feed import GmpGetFeedsTestMixin, GmpGetFeedTestMixin from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/system/test_help.py b/tests/protocols/gmpv225/system/test_help.py index 8df3a0a46..031466118 100644 --- a/tests/protocols/gmpv225/system/test_help.py +++ b/tests/protocols/gmpv225/system/test_help.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.help import GmpHelpTestMixin +from ...gmpv224.system.help import GmpHelpTestMixin from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/system/test_system_reports.py b/tests/protocols/gmpv225/system/test_system_reports.py index 040c06d3a..294768379 100644 --- a/tests/protocols/gmpv225/system/test_system_reports.py +++ b/tests/protocols/gmpv225/system/test_system_reports.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.system_reports import GmpGetSystemReportsTestMixin +from ...gmpv224.system.system_reports import GmpGetSystemReportsTestMixin from ...gmpv225 import Gmpv225TestCase diff --git a/tests/protocols/gmpv225/system/test_trashcan.py b/tests/protocols/gmpv225/system/test_trashcan.py index 833aaec9e..556d5acd0 100644 --- a/tests/protocols/gmpv225/system/test_trashcan.py +++ b/tests/protocols/gmpv225/system/test_trashcan.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.trashcan import ( +from ...gmpv224.system.trashcan import ( GmpEmptyTrashcanTestMixin, GmpRestoreFromTrashcanTestMixin, ) diff --git a/tests/protocols/gmpv225/system/test_user_settings.py b/tests/protocols/gmpv225/system/test_user_settings.py index 06990ad49..4c0f66113 100644 --- a/tests/protocols/gmpv225/system/test_user_settings.py +++ b/tests/protocols/gmpv225/system/test_user_settings.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.user_settings import ( +from ...gmpv224.system.user_settings import ( GmpGetUserSettingsTestMixin, GmpGetUserSettingTestMixin, GmpModifyUserSettingTestMixin, diff --git a/tests/protocols/gmpv225/system/test_versions.py b/tests/protocols/gmpv225/system/test_versions.py index cc87d1c5a..aeb7c980e 100644 --- a/tests/protocols/gmpv225/system/test_versions.py +++ b/tests/protocols/gmpv225/system/test_versions.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from ...gmpv208.system.versions import GmpGetVersionTestCase +from ...gmpv224.system.versions import GmpGetVersionTestCase from ...gmpv225 import Gmpv225TestCase from .versions import GmpGetProtocolVersionTestCase diff --git a/tests/protocols/gmpv225/test_gmp_types.py b/tests/protocols/gmpv225/test_gmp_types.py index 74553ed82..36aad27c6 100644 --- a/tests/protocols/gmpv225/test_gmp_types.py +++ b/tests/protocols/gmpv225/test_gmp_types.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -from gvm.protocols.gmpv208.entities.hosts import HostsOrdering +from gvm.protocols.gmp.requests.v225 import HostsOrdering from . import Gmpv225TestCase diff --git a/tests/protocols/osp/test_osp_delete_scan.py b/tests/protocols/osp/test_osp_delete_scan.py index e50d868f1..ab5511073 100644 --- a/tests/protocols/osp/test_osp_delete_scan.py +++ b/tests/protocols/osp/test_osp_delete_scan.py @@ -19,12 +19,15 @@ def test_delete_scan(self): self.osp.delete_scan(scan_id="123-456") self.connection.send.has_been_called_with( - '' + b'' ) def test_delete_scan_without_id(self): with self.assertRaises(ValueError): - self.osp.delete_scan() + self.osp.delete_scan(None) + + with self.assertRaises(ValueError): + self.osp.delete_scan("") if __name__ == "__main__": diff --git a/tests/protocols/osp/test_osp_get_scanner_details.py b/tests/protocols/osp/test_osp_get_scanner_details.py index 7bc78ce30..16aa3682c 100644 --- a/tests/protocols/osp/test_osp_get_scanner_details.py +++ b/tests/protocols/osp/test_osp_get_scanner_details.py @@ -18,7 +18,7 @@ def setUp(self): def test_get_scanner_details_with_params(self): self.osp.get_scanner_details() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") if __name__ == "__main__": diff --git a/tests/protocols/osp/test_osp_get_scans.py b/tests/protocols/osp/test_osp_get_scans.py index 2d5121513..de4d0c603 100644 --- a/tests/protocols/osp/test_osp_get_scans.py +++ b/tests/protocols/osp/test_osp_get_scans.py @@ -19,14 +19,14 @@ def test_get_scans_with_params(self): self.osp.get_scans(scan_id="123-456", details=False, pop_results=False) self.connection.send.has_been_called_with( - '' + b'' ) def test_get_scans_default_params(self): self.osp.get_scans() self.connection.send.has_been_called_with( - '' + b'' ) diff --git a/tests/protocols/osp/test_osp_get_version.py b/tests/protocols/osp/test_osp_get_version.py index 42adaf7b2..5dc4bf0b8 100644 --- a/tests/protocols/osp/test_osp_get_version.py +++ b/tests/protocols/osp/test_osp_get_version.py @@ -18,7 +18,7 @@ def setUp(self): def test_get_version(self): self.osp.get_version() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") if __name__ == "__main__": diff --git a/tests/protocols/osp/test_osp_get_vts.py b/tests/protocols/osp/test_osp_get_vts.py index 71248f445..07bee68ce 100644 --- a/tests/protocols/osp/test_osp_get_vts.py +++ b/tests/protocols/osp/test_osp_get_vts.py @@ -19,13 +19,13 @@ def test_get_vts_with_vt(self): self.osp.get_vts(vt_id="1.1.1.1.1.1") self.connection.send.has_been_called_with( - '' + b'' ) def test_get_vts(self): self.osp.get_vts() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") if __name__ == "__main__": diff --git a/tests/protocols/osp/test_osp_help.py b/tests/protocols/osp/test_osp_help.py index d80287ef2..919a6171c 100644 --- a/tests/protocols/osp/test_osp_help.py +++ b/tests/protocols/osp/test_osp_help.py @@ -18,7 +18,7 @@ def setUp(self): def test_help(self): self.osp.help() - self.connection.send.has_been_called_with("") + self.connection.send.has_been_called_with(b"") if __name__ == "__main__": diff --git a/tests/protocols/osp/test_osp_start_scan.py b/tests/protocols/osp/test_osp_start_scan.py index 02565398a..d24523b2f 100644 --- a/tests/protocols/osp/test_osp_start_scan.py +++ b/tests/protocols/osp/test_osp_start_scan.py @@ -52,22 +52,22 @@ def test_start_scan(self): ) self.connection.send.has_been_called_with( - '' - '' - "localhost" - "22,80" - "192.168.10.1" - "443" - "" - '' - "username" - "pass" - "" - "" - '' - 'value' - '' - "" + b'' + b'' + b"localhost" + b"22,80" + b"192.168.10.1" + b"443" + b"" + b'' + b"username" + b"pass" + b"" + b"" + b'' + b'value' + b'' + b"" ) def test_start_scan_without_target(self): @@ -79,9 +79,9 @@ def test_start_scan_legacy(self): scan_id="123-456", parallel=10, target="localhost", ports="22" ) self.connection.send.has_been_called_with( - '' - "" + b'' + b"" ) diff --git a/tests/protocols/osp/test_osp_stop_scan.py b/tests/protocols/osp/test_osp_stop_scan.py index b1b170790..f8f2e10c2 100644 --- a/tests/protocols/osp/test_osp_stop_scan.py +++ b/tests/protocols/osp/test_osp_stop_scan.py @@ -20,7 +20,7 @@ def test_stop_scan(self): self.osp.stop_scan(scan_id="123-456") self.connection.send.has_been_called_with( - '' + b'' ) def test_stop_scan_without_id(self): diff --git a/tests/test_enum.py b/tests/test_enum.py new file mode 100644 index 000000000..4a27b099c --- /dev/null +++ b/tests/test_enum.py @@ -0,0 +1,85 @@ +# SPDX-FileCopyrightText: 2024 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm._enum import Enum +from gvm.errors import InvalidArgument + + +class SomeEnum(Enum): + FOO = "foo" + BAR = "bar" + LOREM = "ipsum" + + +class OtherEnum(Enum): + LOREM = "ipsum" + + +class SomeClass: + def __str__(self) -> str: + return "foo" + + +class EnumTestCase(unittest.TestCase): + def test_enum(self) -> None: + enum = SomeEnum("FOO") + self.assertEqual(enum, SomeEnum.FOO) + enum = SomeEnum("BAR") + self.assertEqual(enum, SomeEnum.BAR) + + enum = SomeEnum("foo") + self.assertEqual(enum, SomeEnum.FOO) + enum = SomeEnum("bar") + self.assertEqual(enum, SomeEnum.BAR) + + enum = SomeEnum(SomeClass()) + self.assertEqual(enum, SomeEnum.FOO) + + enum = SomeEnum(SomeEnum.BAR) + self.assertEqual(enum, SomeEnum.BAR) + + enum = SomeEnum(SomeEnum.LOREM) + self.assertEqual(enum, SomeEnum.LOREM) + + enum = SomeEnum("ipsum") + self.assertEqual(enum, SomeEnum.LOREM) + + enum = SomeEnum(OtherEnum.LOREM) + self.assertEqual(enum, SomeEnum.LOREM) + + def test_invalid(self) -> None: + with self.assertRaisesRegex( + InvalidArgument, + "^Invalid argument BAZ. Allowed values are FOO,BAR,LOREM.$", + ): + SomeEnum("BAZ") + + with self.assertRaisesRegex( + ValueError, + "^'' is not a valid SomeEnum$", + ): + SomeEnum("") + + with self.assertRaisesRegex( + ValueError, + "^None is not a valid SomeEnum$", + ): + SomeEnum(None) + + def test_from_string(self) -> None: + enum = SomeEnum.from_string("FOO") + self.assertEqual(enum, SomeEnum.FOO) + enum = SomeEnum.from_string("BAR") + self.assertEqual(enum, SomeEnum.BAR) + + enum = SomeEnum.from_string("foo") + self.assertEqual(enum, SomeEnum.FOO) + enum = SomeEnum.from_string("bar") + self.assertEqual(enum, SomeEnum.BAR) + + def test_str(self): + self.assertEqual(str(SomeEnum.FOO), "foo") + self.assertEqual(str(SomeEnum.BAR), "bar") diff --git a/tests/test_errors.py b/tests/test_errors.py index d2cb9709e..78cb74519 100644 --- a/tests/test_errors.py +++ b/tests/test_errors.py @@ -180,25 +180,25 @@ def test_raise_with_argument_and_arg_type(self): with self.assertRaisesRegex( InvalidArgumentType, "^The argument foo must be of type bar.$" ): - raise InvalidArgumentType("foo", "bar") + raise InvalidArgumentType("foo", arg_type="bar") def test_raise_with_function(self): with self.assertRaisesRegex( InvalidArgumentType, "^In baz the argument foo must be of type bar.$", ): - raise InvalidArgumentType("foo", "bar", function="baz") + raise InvalidArgumentType("foo", arg_type="bar", function="baz") def test_string_conversion(self): with self.assertRaises(InvalidArgumentType) as cm: - raise InvalidArgumentType("foo", "bar") + raise InvalidArgumentType("foo", arg_type="bar") ex = cm.exception self.assertEqual(str(ex), "The argument foo must be of type bar.") self.assertIsNone(ex.function) with self.assertRaises(InvalidArgumentType) as cm: - raise InvalidArgumentType("foo", "bar", function="baz") + raise InvalidArgumentType("foo", arg_type="bar", function="baz") ex = cm.exception self.assertEqual( @@ -207,7 +207,7 @@ def test_string_conversion(self): def test_is_gvm_error(self): with self.assertRaises(GvmError): - raise InvalidArgumentType("foo", "bar") + raise InvalidArgumentType("foo", arg_type="bar") if __name__ == "__main__": diff --git a/tests/utils/test_check_command_status.py b/tests/utils/test_check_command_status.py index 887dc75d2..56c63acd3 100644 --- a/tests/utils/test_check_command_status.py +++ b/tests/utils/test_check_command_status.py @@ -16,6 +16,7 @@ def test_check_command_status_empty(self): false = check_command_status(xml=0) self.assertFalse(false) + self.assertEqual( error_logger.output, [ @@ -31,11 +32,14 @@ def test_check_command_status_failed(self): ) with self.assertLogs("gvm.utils", level="ERROR") as error_logger: self.assertFalse(check_command_status(xml=response)) + self.assertEqual( error_logger.output, [ - "ERROR:gvm.utils:etree.XML(xml): error parsing attribute name, " - "line 1, column 36 (, line 1)" + "ERROR:gvm.utils:Error while parsing the command status: Invalid XML " + '\''. Error was error parsing attribute name, line 1, column 36 " + "(, line 1)" ], ) @@ -43,6 +47,7 @@ def test_check_command_status_error(self): response = "" with self.assertLogs("gvm.utils", level="ERROR") as error_logger: self.assertFalse(check_command_status(xml=response)) + self.assertEqual( error_logger.output, [ diff --git a/tests/utils/test_to_base64.py b/tests/utils/test_to_base64.py index 8ab3c424e..dbf8b1cef 100644 --- a/tests/utils/test_to_base64.py +++ b/tests/utils/test_to_base64.py @@ -11,10 +11,10 @@ class TestToBase64(unittest.TestCase): def test_to_base64(self): foo64 = to_base64("foo") - self.assertEqual(b"Zm9v", foo64) + self.assertEqual("Zm9v", foo64) bar64 = to_base64("bar") - self.assertEqual(b"YmFy", bar64) + self.assertEqual("YmFy", bar64) if __name__ == "__main__": diff --git a/tests/xml/test_valid_xml_string.py b/tests/xml/test_parse_xml.py similarity index 76% rename from tests/xml/test_valid_xml_string.py rename to tests/xml/test_parse_xml.py index 9fe413778..d3c76366b 100644 --- a/tests/xml/test_valid_xml_string.py +++ b/tests/xml/test_parse_xml.py @@ -6,17 +6,17 @@ import unittest from gvm.errors import GvmError -from gvm.xml import validate_xml_string +from gvm.xml import parse_xml -class ValidXmlStringTestCase(unittest.TestCase): +class ParseXmlTestCase(unittest.TestCase): def test_missing_closing_tag(self): with self.assertRaises(GvmError): - validate_xml_string("") + parse_xml("") def test_invalid_tag(self): with self.assertRaises(GvmError): - validate_xml_string("") + parse_xml("") def test_xml_bomb(self): xml = ( @@ -29,4 +29,4 @@ def test_xml_bomb(self): "&c;" ) with self.assertRaises(GvmError): - validate_xml_string(xml) + parse_xml(xml) diff --git a/tests/xml/test_pretty_print.py b/tests/xml/test_pretty_print.py index 8ea8365bf..d791438a4 100644 --- a/tests/xml/test_pretty_print.py +++ b/tests/xml/test_pretty_print.py @@ -8,17 +8,16 @@ from io import StringIO from unittest.mock import patch -import defusedxml.lxml as secET from pontos.testing import temp_directory from gvm.errors import InvalidArgumentType -from gvm.xml import pretty_print +from gvm.xml import parse_xml, pretty_print class PrettyPrintTestCase(unittest.TestCase): def test_pretty_print_to_file(self): xml_str = 'and text' - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) expected_xml_string = ( "\n" " \n" @@ -38,7 +37,7 @@ def test_pretty_print_to_file(self): def test_pretty_print_to_stringio(self): xml_str = 'and text' - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) expected_xml_string = ( "\n" " \n" @@ -59,7 +58,7 @@ def test_pretty_print_to_stringio(self): @patch("sys.stdout", new_callable=StringIO) def test_pretty_print_to_stdout(self, mock_stdout): xml_str = 'and text' - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) expected_xml_string = ( "\n" " \n" @@ -110,7 +109,7 @@ def test_pretty_print_with_string_to_stdout(self, mock_stdout): def test_pretty_print_with_dict(self): xml_str = 'and text' - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) expected_xml_string = ( "\n" " \n" @@ -134,7 +133,7 @@ def test_pretty_print_with_dict(self): def test_pretty_print_with_dict_str(self): xml_str = 'and text' no_xml = "" - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) expected_xml_string = ( "\n" " \n" @@ -160,7 +159,7 @@ def test_pretty_print_no_xml(self): def test_pretty_print_type_error(self): xml_str = 'and text' - elem = secET.fromstring(xml_str) + elem = parse_xml(xml_str) with self.assertRaises(TypeError): pretty_print(elem, file="string")