besapi 3.8.2__tar.gz → 3.9.1__tar.gz

{besapi-3.8.2/src/besapi.egg-info → besapi-3.9.1}/PKG-INFO

@@ -1,10 +1,12 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: besapi
-Version: 3.8.2
+Version: 3.9.1
 Summary: Library for working with the BigFix REST API
 Home-page: https://github.com/jgstew/besapi
 Author: Matt Hansen, James Stewart
 Author-email: hansen.m@psu.edu, james@jgstew.com
+Maintainer: James Stewart
+Maintainer-email: james@jgstew.com
 License: MIT
 Keywords: bigfix iem tem rest api
 Classifier: Programming Language :: Python :: 3
@@ -15,20 +17,14 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Systems Administration
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: requests
-Requires-Dist: lxml
 Requires-Dist: cmd2
+Requires-Dist: lxml
+Requires-Dist: requests
 Requires-Dist: setuptools
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
+Dynamic: license-file
 
 # besapi
 
@@ -42,7 +38,7 @@ Usage:
 
 ```
 import besapi
-b = besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
+b = besapi.besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
 rr = b.get('sites')
 
 # rr.request contains the original request object

{besapi-3.8.2 → besapi-3.9.1}/README.md

@@ -10,7 +10,7 @@ Usage:
 
 ```
 import besapi
-b = besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
+b = besapi.besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
 rr = b.get('sites')
 
 # rr.request contains the original request object

besapi-3.9.1/setup.cfg

@@ -0,0 +1,46 @@
+[metadata]
+name = besapi
+author = Matt Hansen, James Stewart
+author_email = hansen.m@psu.edu, james@jgstew.com
+maintainer = James Stewart
+maintainer_email = james@jgstew.com
+version = attr: besapi.besapi.__version__
+description = Library for working with the BigFix REST API
+keywords = bigfix iem tem rest api
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/jgstew/besapi
+license = MIT
+license_file = LICENSE.txt
+classifiers = 
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3.9
+	Operating System :: OS Independent
+	License :: OSI Approved :: MIT License
+	Development Status :: 5 - Production/Stable
+	Intended Audience :: Developers
+	Topic :: Software Development :: Libraries :: Python Modules
+	Topic :: System :: Systems Administration
+package_dir = 
+	= src
+
+[options]
+python_requires = >=3.9
+include_package_data = True
+packages = find:
+install_requires = 
+	cmd2
+	lxml
+	requests
+	setuptools
+
+[options.package_data]
+besapi = schemas/*.xsd
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

besapi-3.9.1/setup.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+"""File to configure python build and packaging for pip."""
+
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

{besapi-3.8.2 → besapi-3.9.1}/src/besapi/besapi.py

@@ -12,24 +12,20 @@ Library for communicating with the BES (BigFix) REST API.
 import configparser
 import datetime
 import hashlib
+import importlib.resources
 import json
 import logging
 import os
 import random
 import site
 import string
-import typing
-
-try:
-    from urllib import parse
-except ImportError:
-    from urlparse import parse_qs as parse  # type: ignore[no-redef,import-not-found]
+import urllib.parse
 
+import lxml.etree
+import lxml.objectify
 import requests
-from lxml import etree, objectify
-from pkg_resources import resource_filename
 
-__version__ = "3.8.2"
+__version__ = "3.9.1"
 
 besapi_logger = logging.getLogger("besapi")
 
@@ -48,7 +44,7 @@ def rand_password(length=20):
 
 def sanitize_txt(*args):
     """Clean arbitrary text for safe file system usage."""
-    valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
+    valid_chars = f"-_.() {string.ascii_letters}{string.digits}"
 
     sani_args = []
     for arg in args:
@@ -158,7 +154,7 @@ def parse_bes_modtime(string_datetime):
 #         )
 
 
-def get_action_combined_relevance(relevances: typing.List[str]):
+def get_action_combined_relevance(relevances: list[str]):
     """Take array of ordered relevance clauses and return relevance string for
     action.
     """
@@ -249,17 +245,19 @@ def get_target_xml(targets=None):
 def validate_xsd(doc):
     """Validate results using XML XSDs."""
     try:
-        xmldoc = etree.fromstring(doc)
+        xmldoc = lxml.etree.fromstring(doc)
     except BaseException:  # pylint: disable=broad-except
         return False
 
     for xsd in ["BES.xsd", "BESAPI.xsd", "BESActionSettings.xsd"]:
-        xmlschema_doc = etree.parse(resource_filename(__name__, "schemas/%s" % xsd))
+        schema_path = importlib.resources.files(__package__) / f"schemas/{xsd}"
+        with schema_path.open("r") as xsd_file:
+            xmlschema_doc = lxml.etree.parse(xsd_file)
 
         # one schema may throw an error while another will validate
         try:
-            xmlschema = etree.XMLSchema(xmlschema_doc)
-        except etree.XMLSchemaParseError as err:
+            xmlschema = lxml.etree.XMLSchema(xmlschema_doc)
+        except lxml.etree.XMLSchemaParseError as err:
             # this should only error if the XSD itself is malformed
             besapi_logger.error("ERROR with `%s`: %s", xsd, err)
             raise err
@@ -392,7 +390,7 @@ class BESConnection:
         if path.startswith(self.rootserver):
             url = path
         else:
-            url = "%s/api/%s" % (self.rootserver, path)
+            url = f"{self.rootserver}/api/{path}"
 
         return url
 
@@ -414,9 +412,9 @@ class BESConnection:
                 if validate_xml:
                     logging.error(err_msg)
                     raise ValueError(err_msg)
-                else:
-                    # this is intended it validate_xml is None, but not used currently
-                    logging.warning(err_msg)
+
+                # this is intended it validate_xml is None, but not used currently
+                logging.warning(err_msg)
 
         self.last_connected = datetime.datetime.now()
         return RESTResult(
@@ -435,9 +433,9 @@ class BESConnection:
                 if validate_xml:
                     logging.error(err_msg)
                     raise ValueError(err_msg)
-                else:
-                    # this is intended it validate_xml is None, but not used currently
-                    logging.warning(err_msg)
+
+                # this is intended it validate_xml is None, but not used currently
+                logging.warning(err_msg)
 
         return RESTResult(
             self.session.put(self.url(path), data=data, verify=self.verify, **kwargs)
@@ -450,13 +448,50 @@ class BESConnection:
             self.session.delete(self.url(path), verify=self.verify, **kwargs)
         )
 
+    def session_relevance_json(self, relevance, **kwargs):
+        """Get Session Relevance Results in JSON.
+
+        This will submit the relevance string as json instead of html form data.
+        """
+        session_relevance = urllib.parse.quote(relevance, safe=":+")
+        rel_data = {"output": "json", "relevance": session_relevance}
+        self.last_connected = datetime.datetime.now()
+        result = RESTResult(
+            self.session.post(
+                self.url("query"),
+                data=rel_data,
+                verify=self.verify,
+                **kwargs,
+            )
+        )
+        return json.loads(result.text)
+
+    def session_relevance_json_array(self, relevance, **kwargs):
+        """Get Session Relevance Results in an array from the json return.
+
+        This will submit the relevance string as json instead of html form data.
+        """
+        result = self.session_relevance_json(relevance, **kwargs)
+        return result["result"]
+
+    def session_relevance_json_string(self, relevance, **kwargs):
+        """Get Session Relevance Results in a string from the json return.
+
+        This will submit the relevance string as json instead of html form data.
+        """
+        # not sure if the following is needed to handle some cases:
+        # relevance = "(it as string) of ( " + relevance + " )"
+        rel_result_array = self.session_relevance_json_array(relevance, **kwargs)
+        # Ensure each element is converted to a string
+        return "\n".join(map(str, rel_result_array))
+
     def session_relevance_xml(self, relevance, **kwargs):
         """Get Session Relevance Results XML."""
         self.last_connected = datetime.datetime.now()
         return RESTResult(
             self.session.post(
                 self.url("query"),
-                data=f"relevance={parse.quote(relevance, safe=':+')}",
+                data=f"relevance={urllib.parse.quote(relevance, safe=':+')}",
                 verify=self.verify,
                 **kwargs,
             )
@@ -626,6 +661,8 @@ class BESConnection:
             self.site_path = site_path
             return self.site_path
 
+        return None
+
     def import_bes_to_site(self, bes_file_path, site_path=None):
         """Import bes file to site."""
 
@@ -651,7 +688,7 @@ class BESConnection:
 
     def create_site_from_file(self, bes_file_path, site_type="custom"):
         """Create new site."""
-        xml_parsed = etree.parse(bes_file_path)
+        xml_parsed = lxml.etree.parse(bes_file_path)
         new_site_name = xml_parsed.xpath("/BES/CustomSite/Name/text()")[0]
 
         result_site_path = self.validate_site_path(
@@ -662,7 +699,7 @@ class BESConnection:
             besapi_logger.warning("Site `%s` already exists", result_site_path)
             return None
 
-        result_site = self.post("sites", etree.tostring(xml_parsed))
+        result_site = self.post("sites", lxml.etree.tostring(xml_parsed))
 
         return result_site
 
@@ -678,7 +715,7 @@ class BESConnection:
 
     def create_user_from_file(self, bes_file_path):
         """Create user from xml."""
-        xml_parsed = etree.parse(bes_file_path)
+        xml_parsed = lxml.etree.parse(bes_file_path)
         new_user_name = xml_parsed.xpath("/BESAPI/Operator/Name/text()")[0]
         result_user = self.get_user(new_user_name)
 
@@ -686,7 +723,7 @@ class BESConnection:
             besapi_logger.warning("User `%s` Already Exists!", new_user_name)
             return result_user
         besapi_logger.info("Creating User `%s`", new_user_name)
-        _ = self.post("operators", etree.tostring(xml_parsed))
+        _ = self.post("operators", lxml.etree.tostring(xml_parsed))
         # print(user_result)
         return self.get_user(new_user_name)
 
@@ -708,7 +745,7 @@ class BESConnection:
     def create_group_from_file(self, bes_file_path, site_path=None):
         """Create a new group."""
         site_path = self.get_current_site_path(site_path)
-        xml_parsed = etree.parse(bes_file_path)
+        xml_parsed = lxml.etree.parse(bes_file_path)
         new_group_name = xml_parsed.xpath("/BES/ComputerGroup/Title/text()")[0]
 
         existing_group = self.get_computergroup(new_group_name, site_path)
@@ -719,7 +756,7 @@ class BESConnection:
 
         # print(lxml.etree.tostring(xml_parsed))
 
-        _ = self.post(f"computergroups/{site_path}", etree.tostring(xml_parsed))
+        _ = self.post(f"computergroups/{site_path}", lxml.etree.tostring(xml_parsed))
 
         return self.get_computergroup(site_path, new_group_name)
 
@@ -844,7 +881,7 @@ class BESConnection:
     def update_item_from_file(self, file_path, site_path=None):
         """Update an item by name and last modified."""
         site_path = self.get_current_site_path(site_path)
-        bes_tree = etree.parse(file_path)
+        bes_tree = lxml.etree.parse(file_path)
 
         with open(file_path, "rb") as f:
             content = f.read()
@@ -1130,7 +1167,7 @@ class RESTResult:
         """Property for python dict representation."""
         if self._besdict is None:
             if self.valid:
-                self._besdict = elem2dict(etree.fromstring(self.besxml))
+                self._besdict = elem2dict(lxml.etree.fromstring(self.besxml))
             else:
                 self._besdict = {"text": str(self)}
 
@@ -1154,11 +1191,11 @@ class RESTResult:
     def xmlparse_text(self, text):
         """Parse response text as xml."""
         if type(text) is str:
-            root_xml = etree.fromstring(text.encode("utf-8"))
+            root_xml = lxml.etree.fromstring(text.encode("utf-8"))
         else:
             root_xml = text
 
-        return etree.tostring(root_xml, encoding="utf-8", xml_declaration=True)
+        return lxml.etree.tostring(root_xml, encoding="utf-8", xml_declaration=True)
 
     def objectify_text(self, text):
         """Parse response text as objectified xml."""
@@ -1167,7 +1204,7 @@ class RESTResult:
         else:
             root_xml = text
 
-        return objectify.fromstring(root_xml)
+        return lxml.objectify.fromstring(root_xml)
 
 
 def main():

besapi-3.9.1/src/besapi/plugin_utilities_win.py

@@ -0,0 +1,167 @@
+"""
+Plugin utilities for Windows systems, including DPAPI encryption/decryption
+and Windows Registry access.
+"""
+
+import base64
+import logging
+import sys
+from typing import Union
+
+logger = logging.getLogger(__name__)
+
+try:
+    import winreg
+except (ImportError, ModuleNotFoundError) as e:
+    if not sys.platform.startswith("win"):
+        raise RuntimeError(
+            "This script requires the 'winreg' module, which is only available on Windows."
+        ) from e
+    else:
+        raise e
+
+try:
+    import win32crypt
+except (ImportError, ModuleNotFoundError) as e:
+    if not sys.platform.startswith("win"):
+        raise RuntimeError("This script only works on Windows systems") from e
+    raise ImportError(
+        "This script requires the pywin32 package. Install it via 'pip install pywin32'."
+    ) from e
+
+
+def win_dpapi_encrypt_str(
+    plaintext: str, scope_flags: int = 4, entropy: Union[str, bytes, None] = None
+) -> Union[str, None]:
+    """Encrypt a string using Windows DPAPI and return it as a base64-encoded string.
+
+    Args:
+        plaintext (str): The string to encrypt.
+        scope_flags (int): The context scope for encryption (default is 4).
+        entropy (bytes | None): Optional entropy for encryption.
+
+    Returns:
+        str: The base64-encoded encrypted string.
+    """
+    if not plaintext or plaintext.strip() == "":
+        logger.warning("No plaintext provided for encryption.")
+        return None
+
+    # 1. Convert the plaintext string to bytes
+    plaintext_bytes = plaintext.encode("utf-8")
+
+    # 2. Call CryptProtectData.
+    # The last parameter (flags) is set to 4
+    # to indicate that the data should be encrypted in the machine context.
+    #
+    # The function returns a tuple: (description, encrypted_bytes)
+    # We only need the second element.
+    encrypted_bytes = win32crypt.CryptProtectData(
+        plaintext_bytes,
+        None,  # Description
+        entropy,  # Optional entropy
+        None,  # Reserved
+        None,  # Prompt Struct
+        scope_flags,
+    )
+
+    # 3. Encode the encrypted bytes to a Base64 string
+    encrypted_b64 = base64.b64encode(encrypted_bytes).decode("utf-8")
+
+    return encrypted_b64
+
+
+def win_dpapi_decrypt_base64(
+    encrypted_b64: str, scope_flags: int = 4, entropy: Union[str, bytes, None] = None
+) -> Union[str, None]:
+    """Decrypt a base64-encoded string encrypted with Windows DPAPI.
+
+    Args:
+        encrypted_b64 (str): The base64-encoded encrypted string.
+        scope_flags (int): The context scope for decryption (default is 4).
+        entropy (bytes | None): Optional entropy for decryption.
+
+    Returns:
+        str: The decrypted string.
+    """
+    if not encrypted_b64 or encrypted_b64.strip() == "":
+        logger.warning("No encrypted data provided for decryption.")
+        return None
+
+    # 1. Decode the Base64 string to get the raw encrypted bytes
+    encrypted_bytes = base64.b64decode(encrypted_b64)
+
+    # 2. Call CryptUnprotectData.
+    # The last parameter (flags) is set to 4
+    # to indicate that the data was encrypted in the machine context.
+    #
+    # The function returns a tuple: (description, decrypted_bytes)
+    # We only need the second element.
+    _, decrypted_bytes = win32crypt.CryptUnprotectData(
+        encrypted_bytes,
+        entropy,  # Optional entropy
+        None,  # Reserved
+        None,  # Prompt Struct
+        scope_flags,
+    )
+
+    return decrypted_bytes.decode("utf-8") if decrypted_bytes else None
+
+
+def win_registry_value_read(hive, subkey, value_name):
+    """
+    Reads a value from the Windows Registry.
+
+    Args:
+        hive: The root hive (e.g., winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER).
+        subkey: The path to the subkey (e.g., "SOFTWARE\\Microsoft\\Windows\\CurrentVersion").
+        value_name: The name of the value to read.
+
+    Returns:
+        The value data if found, otherwise None.
+    """
+    try:
+        # Open the specified registry key
+        key = winreg.OpenKey(hive, subkey, 0, winreg.KEY_READ)
+
+        # Query the value data
+        value_data, _ = winreg.QueryValueEx(key, value_name)
+
+        # Close the key
+        winreg.CloseKey(key)
+
+        return value_data
+    except FileNotFoundError:
+        logger.error("Registry key or value '%s\\%s' not found.", subkey, value_name)
+        return None
+    except Exception as e:
+        logger.error("An error occurred: %s", e)
+        return None
+
+
+def get_win_registry_rest_pass():
+    """
+    Retrieves the base64 encrypted REST Password from the Windows Registry.
+
+    Returns:
+        The REST Password if found, otherwise None.
+    """
+    hive = winreg.HKEY_LOCAL_MACHINE
+    # HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\BigFix\Enterprise Server\MFSConfig
+    subkey = r"SOFTWARE\Wow6432Node\BigFix\Enterprise Server\MFSConfig"
+    value_name = "RESTPassword"
+
+    reg_value = win_registry_value_read(hive, subkey, value_name)
+
+    if not reg_value:
+        logger.error("No registry value found for RESTPassword.")
+        return None
+
+    # remove {obf} from start of string if present:
+    if reg_value and reg_value.startswith("{obf}"):
+        reg_value = reg_value[5:]
+
+    if reg_value:
+        return win_dpapi_decrypt_base64(reg_value)
+
+    return None

{besapi-3.8.2 → besapi-3.9.1/src/besapi.egg-info}/PKG-INFO

@@ -1,10 +1,12 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: besapi
-Version: 3.8.2
+Version: 3.9.1
 Summary: Library for working with the BigFix REST API
 Home-page: https://github.com/jgstew/besapi
 Author: Matt Hansen, James Stewart
 Author-email: hansen.m@psu.edu, james@jgstew.com
+Maintainer: James Stewart
+Maintainer-email: james@jgstew.com
 License: MIT
 Keywords: bigfix iem tem rest api
 Classifier: Programming Language :: Python :: 3
@@ -15,20 +17,14 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Systems Administration
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: requests
-Requires-Dist: lxml
 Requires-Dist: cmd2
+Requires-Dist: lxml
+Requires-Dist: requests
 Requires-Dist: setuptools
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
+Dynamic: license-file
 
 # besapi
 
@@ -42,7 +38,7 @@ Usage:
 
 ```
 import besapi
-b = besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
+b = besapi.besapi.BESConnection('my_username', 'my_password', 'https://rootserver.domain.org:52311')
 rr = b.get('sites')
 
 # rr.request contains the original request object

{besapi-3.8.2 → besapi-3.9.1}/src/besapi.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/besapi/__init__.py
 src/besapi/__main__.py
 src/besapi/besapi.py
 src/besapi/plugin_utilities.py
+src/besapi/plugin_utilities_win.py
 src/besapi.egg-info/PKG-INFO
 src/besapi.egg-info/SOURCES.txt
 src/besapi.egg-info/dependency_links.txt
@@ -19,4 +20,5 @@ src/besapi/schemas/BESActionSettings.xsd
 src/bescli/__init__.py
 src/bescli/__main__.py
 src/bescli/bescli.py
+tests/test_besapi.py
 tests/tests.py

{besapi-3.8.2 → besapi-3.9.1}/src/bescli/bescli.py

@@ -32,7 +32,7 @@ except ImportError:
 try:
     from besapi.besapi import __version__
 except ImportError:
-    from besapi import __version__  # type: ignore
+    from besapi import __version__  # type: ignore[attr-defined, no-redef]
 
 
 class BESCLInterface(Cmd):

besapi-3.9.1/tests/test_besapi.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python
+"""Test besapi with pytest.
+
+This was converted from tests/tests.py which was used before this pytest was added.
+"""
+
+import json
+import os
+import random
+import subprocess
+import sys
+
+import pytest
+
+# mypy: disable-error-code="arg-type"
+
+if not os.getenv("TEST_PIP"):
+    # add module folder to import paths for testing local src
+    sys.path.append(
+        os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src")
+    )
+    # reverse the order so we make sure to get the local src module
+    sys.path.reverse()
+
+import besapi
+import besapi.plugin_utilities
+
+if os.name == "nt":
+    import besapi.plugin_utilities_win
+
+
+def test_besapi_version():
+    """Test that the besapi version is not None."""
+    assert besapi.besapi.__version__ is not None
+
+
+def test_rand_password():
+    """Test that the generated random password has the correct length."""
+    assert 15 == len(besapi.besapi.rand_password(15))
+
+
+def test_sanitize_txt():
+    """Test that the sanitize_txt function works correctly."""
+    assert ("test--string", "test") == besapi.besapi.sanitize_txt(
+        r"test/\string", "test%"
+    )
+
+
+def test_replace_text_between():
+    """Test that the replace_text_between function works correctly."""
+    assert "http://localhost:52311/file.example" == besapi.besapi.replace_text_between(
+        "http://example:52311/file.example", "://", ":52311", "localhost"
+    )
+
+
+def test_validate_site_path():
+    """Test the validate_site_path function with various inputs."""
+    assert "master" in besapi.besapi.BESConnection.validate_site_path(
+        "", "master", False
+    )
+    assert "custom/" in besapi.besapi.BESConnection.validate_site_path(
+        "", "custom/Example", False
+    )
+    assert "operator/" in besapi.besapi.BESConnection.validate_site_path(
+        "", "operator/Example", False
+    )
+
+
+def test_validate_xml_bes_file():
+    """Test the validate_xml_bes_file function with good and bad files."""
+    assert besapi.besapi.validate_xml_bes_file("tests/good/RelaySelectTask.bes") is True
+    assert (
+        besapi.besapi.validate_xml_bes_file("tests/good/ComputerGroupsExample.bes")
+        is True
+    )
+    assert (
+        besapi.besapi.validate_xml_bes_file("tests/bad/RelaySelectTask_BAD.bes")
+        is False
+    )
+    assert (
+        besapi.besapi.validate_xml_bes_file("tests/bad/ComputerGroups_BAD.bes") is False
+    )
+
+
+def test_failing_validate_site_path():
+    """Test that validate_site_path raises ValueError for invalid inputs."""
+
+    with pytest.raises(ValueError):
+        besapi.besapi.BESConnection.validate_site_path("", "bad/Example", False)
+
+    with pytest.raises(ValueError):
+        besapi.besapi.BESConnection.validate_site_path("", "bad/master", False)
+
+    with pytest.raises(ValueError):
+        besapi.besapi.BESConnection.validate_site_path("", "", False, True)
+
+    with pytest.raises(ValueError):
+        besapi.besapi.BESConnection.validate_site_path("", None, False, True)
+
+
+class RequestResult:
+    text = "this is just a test"
+    headers: list = []
+
+
+def test_rest_result():
+    """Test the RESTResult class."""
+    request_result = RequestResult()
+    rest_result = besapi.besapi.RESTResult(request_result)
+
+    assert rest_result.besdict is not None
+    assert rest_result.besjson is not None
+    assert b"<BES>Example</BES>" in rest_result.xmlparse_text("<BES>Example</BES>")
+    assert rest_result.text == "this is just a test"
+
+
+def test_parse_bes_modtime():
+    """Test the parse_bes_modtime function."""
+    assert (
+        2017 == besapi.besapi.parse_bes_modtime("Tue, 05 Sep 2017 23:31:48 +0000").year
+    )
+
+
+def test_get_action_combined_relevance():
+    """Test the get_action_combined_relevance function."""
+    assert (
+        "( ( True ) AND ( windows of operating system ) ) AND ( False )"
+        == besapi.besapi.get_action_combined_relevance(
+            ["True", "windows of operating system", "False"]
+        )
+    )
+
+
+def test_get_target_xml():
+    """Test the get_target_xml function with various inputs."""
+    assert "<CustomRelevance>False</CustomRelevance>" == besapi.besapi.get_target_xml()
+    assert "<AllComputers>true</AllComputers>" == besapi.besapi.get_target_xml(
+        "<AllComputers>"
+    )
+    assert "<ComputerID>1</ComputerID>" == besapi.besapi.get_target_xml(1)
+    assert (
+        "<CustomRelevance><![CDATA[not windows of operating system]]></CustomRelevance>"
+        == besapi.besapi.get_target_xml("not windows of operating system")
+    )
+    assert (
+        "<ComputerID>1</ComputerID><ComputerID>2</ComputerID>"
+        == besapi.besapi.get_target_xml([1, 2])
+    )
+    assert (
+        "<ComputerName>Computer 1</ComputerName><ComputerName>Another Computer</ComputerName>"
+        == besapi.besapi.get_target_xml(["Computer 1", "Another Computer"])
+    )
+
+
+def test_bescli():
+    """Test the BESCLInterface class and its methods."""
+    import bescli
+
+    bigfix_cli = bescli.bescli.BESCLInterface()
+
+    # just make sure these don't throw errors:
+    bigfix_cli.do_ls()
+    bigfix_cli.do_clear()
+    bigfix_cli.do_ls()
+    bigfix_cli.do_logout()
+    bigfix_cli.do_error_count()
+    bigfix_cli.do_version()
+    bigfix_cli.do_conf()
+
+    # this should really only run if the config file is present:
+    if bigfix_cli.bes_conn:
+        # session relevance tests require functioning web reports server
+        assert (
+            int(bigfix_cli.bes_conn.session_relevance_string("number of bes computers"))
+            > 0
+        )
+        assert (
+            "test session relevance string result"
+            in bigfix_cli.bes_conn.session_relevance_string(
+                '"test session relevance string result"'
+            )
+        )
+        bigfix_cli.do_set_current_site("master")
+
+        # set working directory to folder this file is in:
+        os.chdir(os.path.dirname(os.path.abspath(__file__)))
+
+        # set working directory to src folder in parent folder
+        os.chdir("../src")
+
+        # Test file upload:
+        upload_result = bigfix_cli.bes_conn.upload(
+            "./besapi/__init__.py", "test_besapi_upload.txt"
+        )
+        # print(upload_result)
+        assert upload_result.besobj.FileUpload.Available == 1
+        assert upload_result.besdict["FileUpload"]["Available"] == "1"
+        assert upload_result.besjson is not None
+        upload_result_json = json.loads(upload_result.besjson)
+        assert upload_result_json["FileUpload"]["Available"] == "1"
+
+        assert "test_besapi_upload.txt</URL>" in str(upload_result)
+        upload_prefetch = bigfix_cli.bes_conn.parse_upload_result_to_prefetch(
+            upload_result
+        )
+        # print(upload_prefetch)
+        assert "prefetch test_besapi_upload.txt sha1:" in upload_prefetch
+
+        dashboard_name = "_PyBESAPI_tests.py"
+        var_name = "TestVarName"
+        var_value = "TestVarValue " + str(random.randint(0, 9999))
+
+        assert var_value in str(
+            bigfix_cli.bes_conn.set_dashboard_variable_value(
+                dashboard_name, var_name, var_value
+            )
+        )
+
+        assert var_value in str(
+            bigfix_cli.bes_conn.get_dashboard_variable_value(dashboard_name, var_name)
+        )
+
+        if os.name == "nt":
+            subprocess.run(
+                'CMD /C python -m besapi ls clear ls conf "query number of bes computers" version error_count exit',
+                check=True,
+            )
+
+        bes_conn = besapi.besapi.get_bes_conn_using_config_file()
+        print("login succeeded:", bes_conn.login())
+        assert bes_conn.login()
+
+
+def test_bes_conn_json():
+    """Test the BESConnection class with JSON output."""
+    bes_conn = besapi.besapi.get_bes_conn_using_config_file()
+    if bes_conn and bes_conn.login():
+        print("testing session_relevance_json")
+        result = bes_conn.session_relevance_json("number of bes computers")
+        assert result is not None
+        assert int(result["result"][0]) > 0
+        result = bes_conn.session_relevance_json(
+            """("[%22" & it & "%22]") of concatenation "%22, %22" of names of bes computers"""
+        )
+        assert result is not None
+        string_first_result_json = result["result"][0]
+        print(string_first_result_json)
+        assert '", "' in string_first_result_json
+        assert '["' in string_first_result_json
+        # NOTE: the following check is specific to my env:
+        if "10.0." in bes_conn.rootserver:
+            print("doing check specific to my env")
+            assert '", "BIGFIX", "' in string_first_result_json
+
+        print("testing session_relevance_json_array")
+        result = bes_conn.session_relevance_json_array("number of bes computers")
+        print(result)
+        assert result is not None
+        assert int(result[0]) > 0
+        print("testing session_relevance_json_string")
+        result = bes_conn.session_relevance_json_string("number of bes computers")
+        print(result)
+        assert result is not None
+        assert int(result) > 0
+        print("testing session_relevance_json_string tuple")
+        result = bes_conn.session_relevance_json_string(
+            '(ids of it, names of it, "TestString") of bes computers'
+        )
+        print(result)
+        assert result is not None
+        assert "TestString" in result
+        # NOTE: the following check is specific to my env:
+        if "10.0." in bes_conn.rootserver:
+            print("doing check specific to my env")
+            assert "BIGFIX" in result
+
+
+def test_plugin_utilities_logging():
+    """Test the plugin_utilities module."""
+    print(besapi.plugin_utilities.get_invoke_folder())
+    print(besapi.plugin_utilities.get_invoke_file_name())
+
+    parser = besapi.plugin_utilities.setup_plugin_argparse(plugin_args_required=False)
+    # allow unknown args to be parsed instead of throwing an error:
+    args, _unknown = parser.parse_known_args()
+
+    # test logging plugin_utilities:
+    import logging
+
+    logging_config = besapi.plugin_utilities.get_plugin_logging_config("./tests.log")
+
+    # this use of logging.basicConfig requires python >= 3.9
+    if sys.version_info >= (3, 9):
+        logging.basicConfig(**logging_config)
+
+        logging.warning("Just testing to see if logging is working!")
+
+        assert os.path.isfile("./tests.log")
+
+
+def test_plugin_utilities_win_dpapi():
+    """Test the Windows DPAPI encryption function, if on Windows."""
+    if not os.name == "nt":
+        pytest.skip("Skipping Windows Registry test on non-Windows system.")
+
+    # only run this test if besapi > v3.8.3:
+    if besapi.besapi.__version__ <= "3.8.3":
+        pytest.skip("Skipping test for besapi <= 3.8.3")
+
+    test_string = "This is just a test string " + str(random.randint(0, 9999))
+    encrypted_str = besapi.plugin_utilities_win.win_dpapi_encrypt_str(test_string)
+    print("Encrypted string:", encrypted_str)
+    assert encrypted_str != ""
+    assert encrypted_str != test_string
+    decrypted_str = besapi.plugin_utilities_win.win_dpapi_decrypt_base64(encrypted_str)
+    print("Decrypted string:", decrypted_str)
+    assert decrypted_str == test_string
+
+
+def test_plugin_utilities_win_win_registry_value_read():
+    """Test reading a Windows registry value."""
+    if not os.name == "nt":
+        pytest.skip("Skipping Windows Registry test on non-Windows system.")
+
+    # only run this test if besapi > v3.8.3:
+    if besapi.besapi.__version__ <= "3.8.3":
+        pytest.skip("Skipping test for besapi <= 3.8.3")
+
+    import winreg
+
+    registry_key = r"SOFTWARE\Microsoft\Windows\CurrentVersion"
+    registry_value = "ProgramFilesDir"
+    result = besapi.plugin_utilities_win.win_registry_value_read(
+        winreg.HKEY_LOCAL_MACHINE, registry_key, registry_value
+    )
+
+    assert result is not None
+    print("Registry value:", result)
+    assert "Program Files" in result
+
+
+def test_plugin_utilities_win_get_win_registry_rest_pass():
+    """Test getting the Windows Registry REST password."""
+    if not os.name == "nt":
+        pytest.skip("Skipping Windows Registry test on non-Windows system.")
+
+    # only run this test if besapi > v3.8.3:
+    if besapi.besapi.__version__ <= "3.8.3":
+        pytest.skip("Skipping test for besapi <= 3.8.3")
+
+    import winreg
+
+    test_string = "This is just a test string " + str(random.randint(0, 9999))
+    encrypted_str = besapi.plugin_utilities_win.win_dpapi_encrypt_str(test_string)
+
+    # write encrypted string to registry for testing:
+    # HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\BigFix\Enterprise Server\MFSConfig
+    subkey = r"SOFTWARE\Wow6432Node\BigFix\Enterprise Server\MFSConfig"
+
+    key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, subkey)
+    winreg.SetValueEx(key, "RESTPassword", 0, winreg.REG_SZ, "{obf}" + encrypted_str)
+    winreg.CloseKey(key)
+
+    result = besapi.plugin_utilities_win.get_win_registry_rest_pass()
+    assert result is not None
+    print("Windows Registry REST password:", result)
+    assert result == test_string

{besapi-3.8.2 → besapi-3.9.1}/tests/tests.py

@@ -2,6 +2,7 @@
 """Test besapi."""
 
 import argparse
+import json
 import os
 import random
 import subprocess
@@ -46,6 +47,13 @@ assert "operator/" in besapi.besapi.BESConnection.validate_site_path(
     "", "operator/Example", False
 )
 
+assert besapi.besapi.validate_xml_bes_file("tests/good/RelaySelectTask.bes") is True
+assert (
+    besapi.besapi.validate_xml_bes_file("tests/good/ComputerGroupsExample.bes") is True
+)
+
+assert besapi.besapi.validate_xml_bes_file("tests/bad/RelaySelectTask_BAD.bes") is False
+
 # start failing tests:
 raised_errors = 0
 
@@ -77,9 +85,9 @@ assert raised_errors == 4
 # end failing tests
 
 
-class RequestResult(object):
+class RequestResult:
     text = "this is just a test"
-    headers = []  # type: ignore
+    headers: list = []
 
 
 request_result = RequestResult()
@@ -159,9 +167,20 @@ if bigfix_cli.bes_conn:
     upload_result = bigfix_cli.bes_conn.upload(
         "./besapi/__init__.py", "test_besapi_upload.txt"
     )
+
     # print(upload_result)
+    # print(upload_result.besobj.FileUpload.Available)
+    assert upload_result.besobj.FileUpload.Available == 1
     assert "test_besapi_upload.txt</URL>" in str(upload_result)
-    print(bigfix_cli.bes_conn.parse_upload_result_to_prefetch(upload_result))
+    upload_result_json = json.loads(upload_result.besjson)
+    # print(upload_result_json["FileUpload"]["Available"])
+    assert upload_result_json["FileUpload"]["Available"] == "1"
+
+    upload_prefetch = bigfix_cli.bes_conn.parse_upload_result_to_prefetch(upload_result)
+    # print(upload_prefetch)
+    assert "prefetch test_besapi_upload.txt sha1:" in upload_prefetch
+    assert "test_besapi_upload.txt" in str(upload_result)
+    # print(bigfix_cli.bes_conn.parse_upload_result_to_prefetch(upload_result))
 
     dashboard_name = "_PyBESAPI_tests.py"
     var_name = "TestVarName"

besapi-3.8.2/setup.cfg

@@ -1,21 +0,0 @@
-[metadata]
-version = attr: besapi.besapi.__version__
-long_description = file: README.md
-long_description_content_type = text/markdown
-classifiers = 
-	Programming Language :: Python :: 3
-	Programming Language :: Python :: 3.9
-	Operating System :: OS Independent
-	License :: OSI Approved :: MIT License
-	Development Status :: 5 - Production/Stable
-	Intended Audience :: Developers
-	Topic :: Software Development :: Libraries :: Python Modules
-	Topic :: System :: Systems Administration
-
-[options]
-python_requires = >=3.7
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

besapi-3.8.2/setup.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python
-"""File to configure python build and packaging for pip."""
-
-import setuptools
-
-setuptools.setup(
-    name="besapi",
-    # version= moved to setup.cfg
-    author="Matt Hansen, James Stewart",
-    author_email="hansen.m@psu.edu, james@jgstew.com",
-    description="Library for working with the BigFix REST API",
-    license="MIT",
-    keywords="bigfix iem tem rest api",
-    url="https://github.com/jgstew/besapi",
-    # long_description= moved to setup.cfg
-    packages=["besapi", "bescli"],
-    package_data={"besapi": ["schemas/*.xsd"]},
-    install_requires=["requests", "lxml", "cmd2", "setuptools"],
-    include_package_data=True,
-    package_dir={"": "src"},
-)

{besapi-3.8.2 → besapi-3.9.1}/src/besapi.egg-info/requires.txt

@@ -1,4 +1,4 @@
-requests
-lxml
 cmd2
+lxml
+requests
 setuptools