vigilant-kit 1.3.0__tar.gz → 1.4.0__tar.gz

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/CHANGELOG.md

@@ -1,4 +1,15 @@
 # Changelog for Vigilant Kit
+## Version 1.4.0
+
+### Code Refactoring
+- Removed `vgl` CLI.
+- Updated `VigilantDriver` class, now scripts can be run without Selenium server, only using local browser.
+- Updated documentation related to new configuration.
+
+### Dependencies
+
+- Removed pacakge: `click`.
+
 
 ## Version 1.3.0
 

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vigilant_kit
-Version: 1.3.0
+Version: 1.4.0
 Summary: Library that makes functional testing with Selenium WebDriver fast and easy. 
 Project-URL: Homepage, https://github.com/ivpel/vigilant
 Project-URL: Bug Tracker, https://github.com/ivpel/vigilant/issues
@@ -8,7 +8,6 @@ Author-email: Pelykh Ivan <ivan.pelykh@protonmail.com>
 License-File: LICENSE
 Keywords: bdd,functional,functional-testing,pytest,selenium,tdd,testing,unittest,webdriver
 Requires-Python: >=3.7
-Requires-Dist: click
 Requires-Dist: psutil
 Requires-Dist: python-dotenv
 Requires-Dist: pyyaml
@@ -60,11 +59,6 @@ conditions, and adaptive waiting mechanisms to accommodate different states and
 And much more! Check list of all available - [Actions](docs/actions.md)
 
 
-Also, CLI scripts included, to make your life easier!
-
-Use `vgl --help` to see all available commands.
-
-
 ## Extending Functionality
 If you need something that is not covered in this library, you still have access to all native `Selenium WebDriver` 
 methods. You can create your own methods or use native `WebDriver` methods and share them on one browser session.
@@ -75,8 +69,6 @@ pip install vigilant-kit
 ```
 
 ## Docs
-### Install
-- [How to install Selenium server & browser drivers](docs/selenium_install.md)
 
 ### Configuration
 - [Vigilant configuration](docs/configuration.md)

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/README.md

@@ -42,11 +42,6 @@ conditions, and adaptive waiting mechanisms to accommodate different states and
 And much more! Check list of all available - [Actions](docs/actions.md)
 
 
-Also, CLI scripts included, to make your life easier!
-
-Use `vgl --help` to see all available commands.
-
-
 ## Extending Functionality
 If you need something that is not covered in this library, you still have access to all native `Selenium WebDriver` 
 methods. You can create your own methods or use native `WebDriver` methods and share them on one browser session.
@@ -57,8 +52,6 @@ pip install vigilant-kit
 ```
 
 ## Docs
-### Install
-- [How to install Selenium server & browser drivers](docs/selenium_install.md)
 
 ### Configuration
 - [Vigilant configuration](docs/configuration.md)

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/docs/configuration.md

@@ -16,9 +16,11 @@ Vigilant can be configured with the following options:
 **SELENIUM_HOST**
 
 - Description: The Selenium server host URL.
-- YAML Path: selenium-configuration.SELENIUM_HOST
+- YAML Path: vgl-configuration.SELENIUM_HOST
 - Example: SELENIUM_HOST: http://127.0.0.1:4444/wd/hub
 
+When use **SELENIUM_HOST**: local - local installed browser will be used.
+
 **SELENIUM_BROWSER**
 
 - Description: The browser to be used for testing.
@@ -42,25 +44,15 @@ Vigilant can be configured with the following options:
 The configuration file `vgl_config.yaml` should be structured as follows:
 
 ```yaml
-selenium-configuration:
+vgl-configuration:
   BASE_URL: http://www.python.org
   SELENIUM_HOST: http://127.0.0.1:4444/wd/hub
   SELENIUM_BROWSER: firefox
   WAIT_TIMEOUT: 10
   LOGGER_LEVEL: INFO
-test-credentials:
-  file: {credentials_file_name}.yaml
 ```
 You can modify the values in the YAML file to suit your specific configuration requirements.
 
-## Test Credentials
-For secure storage of sensitive information like credentials, the YAML configuration file supports referencing an external file:
-```yaml
-test-credentials:
-  file: {credentials_file_name}.yaml
-```
-Ensure that credentials.yaml is properly secured and not checked into version control.
-
 ## Environment Variables
 Vigilant will automatically load these settings as environment variables at runtime. There's no need to manually set 
 environment variables if they are defined in the `vgl_config.yaml` file.

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vigilant_kit"
-version = "1.3.0"
+version = "1.4.0"
 authors = [
   { name="Pelykh Ivan", email="ivan.pelykh@protonmail.com" },
 ]
@@ -14,7 +14,6 @@ requires-python = ">=3.7"
 dependencies = [
     "selenium",
     "python-dotenv",
-    "click",
     "requests",
     "psutil",
     "pyyaml"
@@ -23,7 +22,7 @@ dependencies = [
 keywords = ["testing", "selenium", "webdriver", "pytest", "unittest", "bdd", "tdd", "functional", "functional-testing"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/vigilant", "src/vgl_cli"]
+packages = ["src/vigilant"]
 
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -34,6 +33,3 @@ classifiers = [
 [project.urls]
 "Homepage" = "https://github.com/ivpel/vigilant"
 "Bug Tracker" = "https://github.com/ivpel/vigilant/issues"
-
-[project.scripts]
-vgl = "vgl_cli.vgl:vgl"

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/src/vigilant/driver/__init__.py

@@ -10,17 +10,9 @@ def set_env_variables_from_yaml(yaml_path):
     with open(yaml_path, 'r') as file:
         configs = yaml.safe_load(file)
 
-    selenium_config = configs.get('selenium-configuration', {})
+    selenium_config = configs.get('vgl-configuration', {})
     set_env_variables_from_dict(selenium_config)
 
-    # Handle credentials
-    creds_file_path = configs.get('test-credentials', {}).get('file')
-    if creds_file_path and Path(creds_file_path).exists():
-        with open(creds_file_path, 'r') as creds_file:
-            credentials = yaml.safe_load(creds_file)
-        set_env_variables_from_dict(credentials)
-    else:
-        print(f"Credentials file '{creds_file_path}' not found.")
 
 CONFIG_YAML_FILE = 'vgl_config.yaml'
 

vigilant_kit-1.4.0/src/vigilant/driver/vigilant_driver.py

@@ -0,0 +1,45 @@
+import os
+
+from selenium import webdriver
+
+from vigilant.actions.vigilant_actions import VigilantActions
+from vigilant.logger import logger as log
+
+
+class VigilantDriver(VigilantActions):
+
+    SELENIUM_HOST = os.environ.get("SELENIUM_HOST")
+    SELENIUM_BROWSER = os.environ.get("SELENIUM_BROWSER")
+
+    def __init__(self):
+        browser_options = self.default_browser_options()
+        if self.SELENIUM_HOST in ["local", None, ""]:
+            self.driver = self.create_local_driver_session(browser_options)
+        else:
+            self.driver = self.create_remote_driver_session(browser_options)
+        VigilantActions.__init__(self, self.driver)
+
+    def default_browser_options(self):
+        options = None
+        if self.SELENIUM_BROWSER.lower() == "firefox":
+            options = webdriver.FirefoxOptions()
+        elif self.SELENIUM_BROWSER.lower() == "chrome":
+            options = webdriver.ChromeOptions()
+        log.info(f"Setting default browser options: {self.SELENIUM_BROWSER}")
+        return options
+
+    def create_remote_driver_session(self, browser_options):
+        log.info("Creating remote session.\n"
+                 f"Command executor: {self.SELENIUM_HOST}\n"
+                 f"Browser: {self.SELENIUM_BROWSER}")
+        return webdriver.Remote(command_executor=self.SELENIUM_HOST,
+                                options=browser_options)
+
+    def create_local_driver_session(self, browser_options):
+        log.info("Creating local session.\n"
+                 f"Browser: {self.SELENIUM_BROWSER}")
+        if self.SELENIUM_BROWSER.lower() == "firefox":
+            return webdriver.Firefox(options=browser_options)
+        elif self.SELENIUM_BROWSER.lower() == "chrome":
+            return webdriver.Chrome(options=browser_options)
+        raise ValueError("Unsupported browser specified")

{vigilant_kit-1.3.0 → vigilant_kit-1.4.0}/vgl_config.yaml.example

@@ -1,6 +1,6 @@
 selenium-configuration:
   BASE_URL: http://www.python.org
-  SELENIUM_HOST: http://127.0.0.1:4444/wd/hub
+  SELENIUM_HOST: local #http://127.0.0.1:4444/wd/hub
   SELENIUM_BROWSER: firefox
   WAIT_TIMEOUT: 10
   LOGGER_LEVEL: INFO

vigilant_kit-1.3.0/src/vgl_cli/install_dev_kit_command.py

@@ -1,14 +0,0 @@
-import click
-from .install_webdriver_command import check_version_and_download_driver
-from .install_standalone_command import check_req_and_install_selenium_server
-
-
-@click.command(name='install:dev-kit', help="Install local development kit (Webdriver, Selenium Server, etc)")
-@click.option('-b', '--browser', type=click.Choice(['chrome', 'firefox', 'edge']), required=True)
-def install_dev_kit(browser):
-    check_req_and_install_selenium_server()
-    check_version_and_download_driver(browser)
-
-
-if __name__ == "__main__":
-    install_dev_kit()

vigilant_kit-1.3.0/src/vgl_cli/install_standalone_command.py

@@ -1,44 +0,0 @@
-import click
-import os
-import requests
-
-SELENIUM_SERVER_URL = "https://selenium-release.storage.googleapis.com/3.141/selenium-server-standalone-3.141.59.jar"
-SELENIUM_SERVER_FILE = "selenium-server/selenium-server-standalone.jar"
-
-
-def check_selenium_requirements():
-    java_path = os.popen("which java").read().strip()
-    if not java_path:
-        click.secho("Java is not installed on this machine.", fg="red")
-        return False
-
-    java_version = os.popen("java -version 2>&1 | awk -F '\"' '/version/ {print $2}'").read().strip()
-    major_version = java_version.split('.')[0]
-    if int(major_version) < 9:
-        click.secho(f"Java version {java_version} is not supported. Please install Java 9 or higher.", fg="red")
-        return False
-
-    return True
-
-
-def download_selenium_server():
-    response = requests.get(SELENIUM_SERVER_URL)
-    os.makedirs("selenium-server", exist_ok=True)
-    with open(SELENIUM_SERVER_FILE, "wb") as f:
-        f.write(response.content)
-
-
-def check_req_and_install_selenium_server():
-    if check_selenium_requirements():
-        click.secho("Downloading Selenium Standalone server ...", nl=False)
-        download_selenium_server()
-        click.secho("OK", fg="green")
-
-
-@click.command(name="install:standalone", help="Install Selenium Standalone server.")
-def install_selenium_standalone():
-    check_req_and_install_selenium_server()
-
-
-if __name__ == "__main__":
-    install_selenium_standalone()

vigilant_kit-1.3.0/src/vgl_cli/install_webdriver_command.py

@@ -1,111 +0,0 @@
-import click
-import os
-import platform
-import requests
-import tarfile
-import zipfile
-
-BROWSER_VERSIONS = {
-    "chrome": "https://chromedriver.storage.googleapis.com/LATEST_RELEASE",
-    "firefox": "https://api.github.com/repos/mozilla/geckodriver/releases/latest",
-    "edge": "https://msedgedriver.azureedge.net/LATEST_RELEASE"
-}
-
-
-def get_browser_version(browser):
-    if browser == "chrome":
-        # Get the latest version of Chrome from the output of the "google-chrome --version" command
-        chrome_version = os.popen("google-chrome --version").read().strip().split()[-1]
-        return chrome_version
-    elif browser == "firefox":
-        # Get the latest version of Firefox from the output of the "firefox --version" command
-        firefox_version = os.popen("firefox --version").read().strip().split()[-1]
-        return firefox_version.split('.')[0]
-    elif browser == "edge":
-        try:
-            # Get the latest version of Edge from the output of the "msedge --version" command
-            edge_version = os.popen("msedge --version").read().strip().split()[-1]
-            return edge_version.split('.')[0]
-        except IndexError:
-            click.echo(f"Failed to get {browser} version")
-            return None
-    else:
-        click.echo(f"{browser} is not a supported browser")
-        return None
-
-
-def download_driver(browser, version):
-    download_url = None
-    if browser in BROWSER_VERSIONS:
-        if browser == "chrome":
-            # Get the major version of the Chrome browser installed on the machine
-            chrome_version = get_browser_version(browser)
-            if chrome_version is None:
-                click.secho(f"{browser} is not installed on this machine.", fg="red")
-                return
-            # Use the ChromeDriver API to get the latest version of the ChromeDriver that is compatible with the installed Chrome browser
-            response = requests.get(f"https://chromedriver.storage.googleapis.com/LATEST_RELEASE_{chrome_version.split('.')[0]}")
-            if response.status_code == 200:
-                latest_version = response.text
-                download_url = f"https://chromedriver.storage.googleapis.com/{latest_version}/chromedriver_{platform.system().lower()}64.zip"
-            else:
-                click.secho(f"Could not find latest {browser} driver version.", fg="red")
-        elif browser == "firefox":
-            r = requests.get(BROWSER_VERSIONS[browser])
-            release_info = r.json()
-            for asset in release_info["assets"]:
-                if platform.system().lower() in asset["name"] and "tar.gz" in asset["name"]:
-                    download_url = asset["browser_download_url"]
-                    break
-            else:
-                click.secho(f"Could not find latest {browser} driver version... Fail", fg="red")
-        elif browser == "edge":
-            download_url = f"https://msedgedriver.azureedge.net/{version}/edgedriver_{platform.system().lower()}.zip"
-        else:
-            click.secho(f"Invalid browser name '{browser}'", fg="red")
-            return
-    else:
-        click.secho(f"Could not find browser '{browser}'.", fg="red")
-        return
-
-    if download_url is not None:
-        response = requests.get(download_url)
-        if download_url.endswith(".zip"):
-            with open(f"selenium-server/{browser}_driver.zip", "wb") as f:
-                f.write(response.content)
-            with zipfile.ZipFile(f"selenium-server/{browser}_driver.zip", 'r') as zip_ref:
-                for member in zip_ref.namelist():
-                    zip_ref.extract(member, f"selenium-server/")
-        elif download_url.endswith(".tar.gz"):
-            with open(f"selenium-server/{browser}_driver.tar.gz", "wb") as f:
-                f.write(response.content)
-            with tarfile.open(f"selenium-server/{browser}_driver.tar.gz", 'r:gz') as tar_ref:
-                tar_ref.extractall(f"selenium-server/")
-    else:
-        click.secho(f"Could not find download URL for {browser} driver.", fg="red")
-
-
-def check_version_and_download_driver(browser):
-    version = get_browser_version(browser)
-    if version is None:
-        click.secho(f"{browser} is not installed on this machine", fg="red")
-    else:
-        click.secho(f"Found: {browser} browser, version {version}.", fg="cyan")
-        # Download the driver for the browser
-        click.echo(f"Downloading driver for {browser} browser ... ", nl=False)
-        download_driver(browser, version)
-        click.secho("OK", fg="green")
-
-
-@click.command(name='install:webdriver', help="Install the webdriver for a chosen browser.")
-@click.option('-b', '--browser', type=click.Choice(['chrome', 'firefox', 'edge']), required=True)
-def install_webdriver(browser):
-    # Create the selenium-server directory if it doesn't exist
-    os.makedirs("selenium-server", exist_ok=True)
-
-    # Check if the browser is installed and get its version
-    check_version_and_download_driver(browser)
-
-
-if __name__ == "__main__":
-    install_webdriver()

vigilant_kit-1.3.0/src/vgl_cli/selenium_commands.py

@@ -1,47 +0,0 @@
-import subprocess
-import click
-import psutil
-
-SELENIUM_SERVER_JAR = "selenium-server/selenium-server-standalone.jar"
-
-
-def find_selenium_server_process():
-    for process in psutil.process_iter(['pid', 'name', 'cmdline']):
-        if process.info['name'] == 'java' and SELENIUM_SERVER_JAR in process.info['cmdline']:
-            return process
-    return None
-
-
-@click.command(name='server:run', help="Run Selenium Server JAR file")
-@click.option('--port', '-p', type=int, default=4444, help="Port number for the server")
-@click.option('--driver', '-D', multiple=True,
-              help="Specify driver options (e.g. -Dwebdriver.chrome.driver=chromedriver)")
-@click.option('--daemon', '-d', is_flag=True, help="Run the server as a daemon")
-def run_selenium_server(port, driver, daemon):
-    driver_options = " ".join(driver)
-    cmd = ["java", "-jar", SELENIUM_SERVER_JAR, "-port", str(port)]
-    cmd.extend(driver_options.split())
-
-    click.echo(f"Running Selenium Server with command:\n {' '.join(cmd)}")
-
-    if daemon:
-        # Start the process in the background (daemon mode) using subprocess.Popen
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
-        click.echo(f"Selenium Server is running in daemon mode with PID: {process.pid}")
-    else:
-        # Start the process in the foreground and wait for it to finish using subprocess.run
-        subprocess.run(cmd)
-
-
-@click.command(name='server:stop', help="Stop the running Selenium Server")
-def stop_selenium_server():
-    selenium_server_process = find_selenium_server_process()
-    if selenium_server_process:
-        pid = selenium_server_process.info['pid']
-        try:
-            selenium_server_process.terminate()
-            click.echo(f"Selenium Server with PID {pid} has been stopped.")
-        except psutil.NoSuchProcess:
-            click.echo(f"Failed to stop Selenium Server. Process with PID {pid} does not exist.")
-    else:
-        click.echo("Selenium Server is not running in daemon mode.")

vigilant_kit-1.3.0/src/vgl_cli/vgl.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-
-import click
-from .install_webdriver_command import install_webdriver
-from .install_standalone_command import install_selenium_standalone
-from .install_dev_kit_command import install_dev_kit
-
-from .selenium_commands import run_selenium_server, stop_selenium_server
-
-
-@click.group(name="vgl.py")
-def vgl():
-    pass
-
-
-vgl.add_command(run_selenium_server)
-vgl.add_command(stop_selenium_server)
-
-
-vgl.add_command(install_webdriver)
-vgl.add_command(install_selenium_standalone)
-vgl.add_command(install_dev_kit)
-
-
-if __name__ == '__main__':
-    vgl()

vigilant_kit-1.3.0/src/vigilant/driver/vigilant_driver.py

@@ -1,87 +0,0 @@
-import os
-
-from selenium import webdriver
-
-from vigilant.actions.vigilant_actions import VigilantActions
-from vigilant.logger import logger as log
-
-
-class VigilantDriver(VigilantActions):
-    """
-    VigilantDriver class provide methods for running WebDriver instance from scratch using configuration
-    from .vigilant.env file
-
-    .vigilant.env configuration items:
-    ----------------------------------
-    SELENIUM_HOST - is used as command_executor, it is Selenium Server URI;
-
-    SELENIUM_BROWSER - used as entity that show which browser options to use FirefoxOptions(),
-        ChromeOptions, etc. (DesiredCapabilities is now deprecated, we should use Options() class).
-
-    BASE_URL - the root URL of the application under test
-
-    WAIT_TIMEOUT - configuration for the default amount of time (in seconds) that a
-        test will wait while trying to interact with web element.
-
-    LOGGER_LEVEL - level of verbosity that will be printed in to the console;
-    """
-
-    def __init__(self, browser_options=None):
-        """
-        `driver` - if you want access native Selenium WebDriver methods;
-        VigilantActions - allow you to use custom methods for interaction with browser directly from VigilantDriver
-        class instance;
-
-        Examples:
-            How to use VigilantActions methods;
-
-                act = VigilantDriver()
-                act.get_page('/')
-                act.assertions.see_text('Some Text')
-
-            How to access native Selenium WebDriver methods;
-
-                act = VigilantDriver()
-                act.driver.get('https://python.org') // Here we use Selenium WebDriver get() method
-        """
-        self.driver = self.create_remote_driver_session(browser_options)
-        VigilantActions.__init__(self, self.driver)
-
-    SELENIUM_HOST = os.environ.get("SELENIUM_HOST")
-    SELENIUM_BROWSER = os.environ.get("SELENIUM_BROWSER")
-
-    def default_browser_options(self):
-        """
-        Set browser options according to browser name provided in .vigilant.env file.
-        It can be overwritten when user create new Selenium session by providing options as argument.
-
-        Returns:
-            Options: return default browser options according to value from SELENIUM_BROWSER variable.
-        """
-        options = None
-        if self.SELENIUM_BROWSER.lower() == "firefox":
-            options = webdriver.FirefoxOptions()
-        elif self.SELENIUM_BROWSER.lower() == "chrome":
-            options = webdriver.ChromeOptions()
-        log.info(f"Setting default browser options: {self.SELENIUM_BROWSER}")
-        return options
-
-    def create_remote_driver_session(self, browser_options=None):
-        """
-        Create a new WebDriver instance that will issue commands using the wire protocol.
-
-         Args:
-            browser_options: browser options instance is required as it determines which browser will be used
-
-        Returns:
-            Remote: remote driver session based on configuration from .vigilant.env file
-        """
-        log.info("Creating remote session.\n"
-                 f"Command executor: {self.SELENIUM_HOST}\n"
-                 f"Browser: {self.SELENIUM_BROWSER}")
-
-        if browser_options is None:
-            browser_options = self.default_browser_options()
-
-        return webdriver.Remote(command_executor=self.SELENIUM_HOST,
-                                options=browser_options)