vigilant-kit 1.1.1__tar.gz → 1.2.1__tar.gz

vigilant_kit-1.2.1/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: vigilant_kit
+Version: 1.2.1
+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
+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: python-dotenv
+Requires-Dist: requests
+Requires-Dist: selenium
+Description-Content-Type: text/markdown
+
+# Vigilant Kit
+Vigilant is a set of tools designed to help write and run robust functional tests using Selenium WebDriver. It provides
+methods for interacting with the WebBrowser, assertions, and waiting. With Vigilant, you can start writing complex test
+cases in a minute.
+
+## Why Vigilant?
+- **Easy to start & Fast To Write**: Easy configuration process, straightforward way to writing your tests.
+Vigilant provides you with methods that help you write functional tests quickly without spending time on writing 
+boilerplate code every time you start a new project. 
+- **Flexible Framework Usage**: Usage is not limited to a single testing framework; you can use Vigilant with unittest,
+  pytest, or anything else.
+
+## What it includes?
+Methods for **interacting** with WebBrowser (`click`, `scroll_to`,  etc.), **assertions** (`see`, `dont_see`, `see_text`
+, etc.) **waiters** (`wait_for_element_to_be_visible`, `wait_for_element_to_be_clickable`, etc.)
+It is already there, ready to use.
+
+Also, a bunch of CLI scripts, to make your life easier!
+
+Use `vgl --help` to see all available commands.
+
+List of all available [actions](docs/actions.md).
+
+## 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.
+
+## Install
+```shell
+pip install vigilant-kit
+```
+
+## Docs
+ - [How to install Selenium server & browser drivers](docs/selenium_install.md)
+ - [Quick start example using `unittest` library](docs/vigilant_unittest.md) 
+ - [Quick start example using `pytest`](docs/vigilant_pytest.md) 
+ - [How to add custom browser options](docs/browser_options.md)
+ - [Access native Selenium WebDriver methods](docs/native_selenium.md)
+ - [List of actions](docs/actions.md).
+
+## Tutorials
+ - [Testing ecommerce project using `vigilant-kit` and `pytest`](docs/tutorial_pytest.md)
+ 

vigilant_kit-1.2.1/README.md

@@ -0,0 +1,43 @@
+# Vigilant Kit
+Vigilant is a set of tools designed to help write and run robust functional tests using Selenium WebDriver. It provides
+methods for interacting with the WebBrowser, assertions, and waiting. With Vigilant, you can start writing complex test
+cases in a minute.
+
+## Why Vigilant?
+- **Easy to start & Fast To Write**: Easy configuration process, straightforward way to writing your tests.
+Vigilant provides you with methods that help you write functional tests quickly without spending time on writing 
+boilerplate code every time you start a new project. 
+- **Flexible Framework Usage**: Usage is not limited to a single testing framework; you can use Vigilant with unittest,
+  pytest, or anything else.
+
+## What it includes?
+Methods for **interacting** with WebBrowser (`click`, `scroll_to`,  etc.), **assertions** (`see`, `dont_see`, `see_text`
+, etc.) **waiters** (`wait_for_element_to_be_visible`, `wait_for_element_to_be_clickable`, etc.)
+It is already there, ready to use.
+
+Also, a bunch of CLI scripts, to make your life easier!
+
+Use `vgl --help` to see all available commands.
+
+List of all available [actions](docs/actions.md).
+
+## 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.
+
+## Install
+```shell
+pip install vigilant-kit
+```
+
+## Docs
+ - [How to install Selenium server & browser drivers](docs/selenium_install.md)
+ - [Quick start example using `unittest` library](docs/vigilant_unittest.md) 
+ - [Quick start example using `pytest`](docs/vigilant_pytest.md) 
+ - [How to add custom browser options](docs/browser_options.md)
+ - [Access native Selenium WebDriver methods](docs/native_selenium.md)
+ - [List of actions](docs/actions.md).
+
+## Tutorials
+ - [Testing ecommerce project using `vigilant-kit` and `pytest`](docs/tutorial_pytest.md)
+ 

vigilant_kit-1.2.1/docs/selenium_install.md

@@ -0,0 +1,50 @@
+# How to install Selenium Server & browser drivers
+
+***
+## Option 1: Run Selenium server + browser driver locally
+###  1. Install Selenium Standalone Server and Webdriver
+`vgl install dev-kit -b chrome`
+
+If everything is okay and your machine has all dependencies installed, you will see this output:
+```text
+Found: chrome browser, version 112.0.5615.165.
+Downloading driver for chrome browser ... OK
+Downloading Selenium Standalone server ...OK
+```
+
+### 2. Run Selenium Server
+To run your Selenium Server use:
+`vgl run selenium-server`
+
+This command will launch Selenium Standalone server on your local machine.
+
+### Need help? Use `--help`
+To see all available options for these commands you can use `--help` flag.
+
+For example:
+`vgl run selenium-server --help`
+
+Will output this:
+```text
+Usage: vgl run selenium-server [OPTIONS]
+
+  Run Selenium Server JAR file
+
+Options:
+  -p, --port INTEGER  Port number for the server
+  -D, --driver TEXT   Specify driver options (e.g.
+                      -Dwebdriver.chrome.driver=chromedriver)
+  -d, --daemon        Run the server as a daemon
+  --help              Show this message and exit.
+```
+
+## Option 2: Start Selenium server + browser inside Docker
+***
+If you don't want to install and run Selenium server and the browser locally, you can run both of them in a Docker 
+container. The Selenium project provides many prepared official containers.
+For example to start a container with Selenium server and Firefox, simply run:
+```shell
+docker run -d -p 4446:4444 -p 7902:7900 --shm-size="2g" selenium/standalone-firefox:4.6.0-20221104
+```
+
+For more info about available options check official [Docker Selenium](https://github.com/SeleniumHQ/docker-selenium) page.

vigilant_kit-1.1.1/README.md → vigilant_kit-1.2.1/docs/vigilant_unittest.md

@@ -1,42 +1,3 @@
-# Vigilant Kit
-Vigilant is a set of tools made to help writing and running robust functional tests using Selenium WebDriver.
-
-## Why Vigilant?
- - It allows you to start writing complex test cases in a minute.
- - Simple configuration process (just one `.vigilant.env` file to start)
- - Usage is not limited to a single testing framework, it can be used with `unittest`, `pytest` or anything else.
-It is up to you.
-
-**Vigilant** provide you with methods that help write functional tests fast, without spending your time on writing
-boilerplate code every time you start new project.
-
-Methods for **interacting** with WebBrowser (`click`, `scroll_to`,  etc.), **assertions** (`see`, `dont_see`, `see_text`
-, etc.) **waiting** (`wait_for_element_to_be_visible`, `wait_for_element_to_be_clickable`, etc.)
-It is already there, ready to use.
-
-List of all available [actions](docs/actions.md).
-
-### What if you need something that is not covered in this library?
-
-You still have access to all native `Selenium WebDriver` methods. Despite all functional that library provide - 
-you can create your own methods or use native `WebDriver` methods and share them on one browser session.
-
-## Docs
- - [How to install Selenium server & browser drivers](docs/selenium_install.md)
- - [Quick start example using `unittest` library](docs/vigilant_unittest.md) 
- - [Quick start example using `pytest`](docs/vigilant_pytest.md) 
- - [How to add custom browser options](docs/browser_options.md)
- - [Access native Selenium WebDriver methods](docs/native_selenium.md)
- - [List of actions](docs/actions.md).
-
-## Tutorials
- - [Testing ecommerce project using `vigilant-kit` and `pytest`](docs/tutorial_pytest.md)
- 
-## Install
-```shell
-pip install vigilant-kit
-```
-
 ## Quick start
 We will write our first test with `unittest` library. Also make sure that you installed
 `vigilant-kit` library.
@@ -44,7 +5,7 @@ We will write our first test with `unittest` library. Also make sure that you in
 
 ### Configuration
 Configuration can be done through environment variables. Make sure that your Selenium Server is up and running, if not -
-[**Install Selenium server**](docs/selenium_install.md)
+[**Install Selenium server**](selenium_install.md)
 
 Create `.vigilant.env` file with next data:
 ```shell

{vigilant_kit-1.1.1 → vigilant_kit-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vigilant_kit"
-version = "1.1.1"
+version = "1.2.1"
 authors = [
   { name="Pelykh Ivan", email="ivan.pelykh@protonmail.com" },
 ]

vigilant_kit-1.2.1/src/vgl_cli/install_dev_kit_command.py

@@ -0,0 +1,14 @@
+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='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_version_and_download_driver(browser)
+    check_req_and_install_selenium_server()
+
+
+if __name__ == "__main__":
+    install_dev_kit()

vigilant_kit-1.2.1/src/vgl_cli/install_standalone_command.py

@@ -0,0 +1,44 @@
+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="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.2.1/src/vgl_cli/install_webdriver_command.py

@@ -0,0 +1,111 @@
+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/{browser}_driver/")
+        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/{browser}_driver/")
+    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='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.2.1/src/vgl_cli/run_selenium_command.py

@@ -0,0 +1,22 @@
+import os
+import click
+
+SELENIUM_SERVER_JAR = "selenium-server/selenium-server-standalone.jar"
+
+
+@click.command(name='selenium-server', 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 = f"java -jar {SELENIUM_SERVER_JAR} -port {port} {driver_options}"
+    click.echo(f"Running Selenium Server with command:\n {cmd}")
+    if daemon:
+        cmd += " &"
+    os.system(cmd)
+
+
+if __name__ == "__main__":
+    run_selenium_server()

vigilant_kit-1.2.1/src/vgl_cli/vgl.py

@@ -0,0 +1,38 @@
+#!/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 .run_selenium_command import run_selenium_server
+
+
+@click.group(name="vgl.py")
+def vgl():
+    pass
+
+
+@click.group(name="install", help="Install commands")
+def install_group():
+    pass
+
+
+@click.group(name="run", help="Run commands")
+def run_group():
+    pass
+
+
+run_group.add_command(run_selenium_server)
+
+
+install_group.add_command(install_webdriver)
+install_group.add_command(install_selenium_standalone)
+install_group.add_command(install_dev_kit)
+
+vgl.add_command(install_group)
+vgl.add_command(run_group)
+
+
+if __name__ == '__main__':
+    vgl()

vigilant_kit-1.1.1/PKG-INFO

@@ -1,150 +0,0 @@
-Metadata-Version: 2.1
-Name: vigilant_kit
-Version: 1.1.1
-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
-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: python-dotenv
-Requires-Dist: requests
-Requires-Dist: selenium
-Description-Content-Type: text/markdown
-
-# Vigilant Kit
-Vigilant is a set of tools made to help writing and running robust functional tests using Selenium WebDriver.
-
-## Why Vigilant?
- - It allows you to start writing complex test cases in a minute.
- - Simple configuration process (just one `.vigilant.env` file to start)
- - Usage is not limited to a single testing framework, it can be used with `unittest`, `pytest` or anything else.
-It is up to you.
-
-**Vigilant** provide you with methods that help write functional tests fast, without spending your time on writing
-boilerplate code every time you start new project.
-
-Methods for **interacting** with WebBrowser (`click`, `scroll_to`,  etc.), **assertions** (`see`, `dont_see`, `see_text`
-, etc.) **waiting** (`wait_for_element_to_be_visible`, `wait_for_element_to_be_clickable`, etc.)
-It is already there, ready to use.
-
-List of all available [actions](docs/actions.md).
-
-### What if you need something that is not covered in this library?
-
-You still have access to all native `Selenium WebDriver` methods. Despite all functional that library provide - 
-you can create your own methods or use native `WebDriver` methods and share them on one browser session.
-
-## Docs
- - [How to install Selenium server & browser drivers](docs/selenium_install.md)
- - [Quick start example using `unittest` library](docs/vigilant_unittest.md) 
- - [Quick start example using `pytest`](docs/vigilant_pytest.md) 
- - [How to add custom browser options](docs/browser_options.md)
- - [Access native Selenium WebDriver methods](docs/native_selenium.md)
- - [List of actions](docs/actions.md).
-
-## Tutorials
- - [Testing ecommerce project using `vigilant-kit` and `pytest`](docs/tutorial_pytest.md)
- 
-## Install
-```shell
-pip install vigilant-kit
-```
-
-## Quick start
-We will write our first test with `unittest` library. Also make sure that you installed
-`vigilant-kit` library.
-
-
-### Configuration
-Configuration can be done through environment variables. Make sure that your Selenium Server is up and running, if not -
-[**Install Selenium server**](docs/selenium_install.md)
-
-Create `.vigilant.env` file with next data:
-```shell
-# Selenium host URL
-SELENIUM_HOST=http://127.0.0.1:4444/wd/hub 
-
-# Browser which will performing the tests
-SELENIUM_BROWSER=firefox 
-
-# The root URL of the application under test.
-BASE_URL=http://www.python.org 
-
-# Amount of time (in seconds) that a test will wait while loading a page or waiting for element
-WAIT_TIMEOUT=10 
-
-# Log level
-LOGGER_LEVEL=INFO 
-```
-
-### Test
-Create file `test_first.py` with same code as below. We will cover 3 simple cases for demo purposes.
-```python
-import unittest
-
-from vigilant.driver.vigilant_driver import VigilantDriver
-
-
-class TestHomePage(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        cls.act = VigilantDriver()
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.act.quit()
-
-    def test_home_page(self):
-        # Case 1. Go to some page and assert page title
-        self.act.get_page('/')  # Go to root page
-        self.act.assertions.see_in_title('Python')  # Assert that page title contains 'Python' string
-
-    def test_text_block(self):
-        # Case 2. Scroll to some block and assert visible text
-        self.act.get_page('/')  # Go to root page
-        self.act.scroll_to('//h2[text()="Success Stories"]')  # Scroll to Success Stories block
-        self.act.assertions.see_text('Success Stories')  # Assert that Success Stories string is visible
-
-    def test_search_page(self):
-        # Case 3. Fill in Search field with search key word, assert result in search result page.
-        self.act.get_page('/')  # Go to root page
-        self.act.fill_field('//input[@name="q"]', 'python')  # Fill search field
-        self.act.click('//button[@id="submit"]')  # Click Search button
-        self.act.assertions.see_in_url(
-            '/search/?q=python')  # See in URL that we are redirected to search result page
-        self.act.assertions.see_text('Results')  # Assert visible Results text
-
-
-if __name__ == '__main__':
-    unittest.main()
-
-```
-Now run our script:
-```shell
-python3 test_first.py
-```
-### Results
-If you are running your Selenium Server locally - you can see how script interact with browser in real time. But in any
-case you should have terminal output similar to this, due to LOGGER_LEVEL=INFO:
-```text
-[2022-11-02 16:34:26,452: INFO] Creating remote session.
-Command executor: http://127.0.0.1:4444/wd/hub
-Browser: firefox
-[2022-11-02 16:34:26,452: INFO] Setting default browser options: firefox
-[2022-11-02 16:34:27,890: INFO] Getting page: /
-[2022-11-02 16:34:33,942: INFO] Assert: see string Python in current page title
-[2022-11-02 16:34:33,956: INFO] Scrolling to element: //h2[text()="Success Stories"]
-[2022-11-02 16:34:33,956: INFO] Execute JS script: arguments[0].scrollIntoView({block: "center"}) with arguments: <selenium.webdriver.remote.webelement.WebElement (session="3c63a627-1ffd-40ed-b008-78e671d82085", element="703e049a-3ab4-4bd5-814a-bb38dd64864a")>
-[2022-11-02 16:34:33,980: INFO] Waiting for element with selector: //input[@name="q"] - to be visible.
-[2022-11-02 16:34:33,991: INFO] Filling field: //input[@name="q"] with value: python
-[2022-11-02 16:34:34,012: INFO] Waiting for element with selector: //button[@id="submit"] - to be visible.
-[2022-11-02 16:34:34,026: INFO] Clicking on element: //button[@id="submit"]
-[2022-11-02 16:34:34,411: INFO] Assert: see string /search/?q=python in current page URL
-[2022-11-02 16:34:34,434: INFO] Quits the driver and closes every associated window
-
-```
-Congrats! You successfully created your first testing script using Vigilant Kit :)

vigilant_kit-1.1.1/docs/selenium_install.md

@@ -1,41 +0,0 @@
-# How to install Selenium Server & browser drivers
-
-***
-## Option 1: Run Selenium server + browser driver locally
-### 1. Install Selenium server
-Selenium server is simply a jar file. To install (download) it, just run this command in the root directory
-of your project or root directory of your tests
-```shell
-mkdir selenium-server && cd selenium && wget https://github.com/SeleniumHQ/selenium/releases/download/selenium-4.6.0/selenium-server-4.6.0.jar && cd -
-```
-### 2. Install browser driver
-You will also need to download Selenium driver for the browser where you want to execute the tests. This driver is used
-by Selenium server to start the browser of your choice - see following table for the most common browsers:
-
-| Browser | Driver              | Download link                                                                     |
-|---------|---------------------|-----------------------------------------------------------------------------------|
-| Firefox | Geckodriver         | [Download](https://github.com/mozilla/geckodriver/releases)                       |
-| Chrome  | Chromedriver        | [Download](https://sites.google.com/a/chromium.org/chromedriver/downloads)        |
-| MS Edge | Microsoft WebDriver | [Download](https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/) |
-
-Download the browser driver and place the binary file (like geckodriver or chromedriver) to the `selenium-server/` 
-directory (where our selenium standalone server is located).
-You can also place the file elsewhere, but then you must pass the path to the Selenium server, but as for me, it is easier
-to have server and driver binaries in one place.
-
-### 3. Start Selenium server
-To start the Selenium server listening for incoming connections simply run:
-```shell
-java -jar selenium-server/selenium-server-4.6.0.jar
-```
-
-## Option 2: Start Selenium server + browser inside Docker
-***
-If you don't want to install and run Selenium server and the browser locally, you can run both of them in a Docker 
-container. The Selenium project provides many prepared official containers.
-For example to start a container with Selenium server and Firefox, simply run:
-```shell
-docker run -d -p 4446:4444 -p 7902:7900 --shm-size="2g" selenium/standalone-firefox:4.6.0-20221104
-```
-
-For more info about available options check official [Docker Selenium](https://github.com/SeleniumHQ/docker-selenium) page.

vigilant_kit-1.1.1/docs/vigilant_unittest.md

@@ -1,49 +0,0 @@
-# How to start testing with `unittest` library
-
-If you are not already familiar with the basic concepts of testing, you might want to read this tutorial:
-[unittest](https://docs.python.org/3/library/unittest.html)
-
-Example using `unittest` library.
-```python
-import unittest
-
-from vigilant.driver.vigilant_driver import VigilantDriver
-from selenium.webdriver.firefox.options import Options
-
-
-class TestHomePage(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        cls.act = VigilantDriver()
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.act.quit()
-
-    def test_home_page(self):
-        # Case 1. Go to some page and assert page title
-        self.act.get_page('/')  # Go to root page
-        self.act.assertions.see_in_title('Python')  # Assert that page title contains 'Python' string
-
-    def test_text_block(self):
-        # Case 2. Scroll to some block and assert visible text
-        self.act.get_page('/')  # Go to root page
-        self.act.scroll_to('//h2[text()="Success Stories"]')  # Scroll to Success Stories block
-        self.act.assertions.see_text('Success Stories')  # Assert that Success Stories string is visible
-
-    def test_search_page(self):
-        # Case 3. Fill in Search field with search key word, assert result in search result page.
-        self.act.get_page('/')  # Go to root page
-        self.act.fill_field('//input[@name="q"]', 'python')  # Fill search field
-        self.act.click('//button[@id="submit"]')  # Click Search button
-        self.act.assertions.see_in_url(
-            '/search/?q=python')  # See in URL that we are redirected to search result page
-        self.act.assertions.see_text('Results')  # Assert visible Results text
-
-
-if __name__ == '__main__':
-    unittest.main()
-
-```
-

vigilant_kit-1.1.1/src/vgl_cli/local_dev.py

@@ -1,51 +0,0 @@
-import os
-import sys
-import tarfile
-import click
-from .utils import download_file
-
-
-def install_selenium():
-    try:
-        click.echo("Creating directory for Selenium server...", nl=False)
-        os.mkdir('selenium')
-        os.chdir('selenium')
-        click.secho("OK", fg='green')
-
-        # Download Selenium jar file
-        click.echo("Downloading Selenium jar file...", nl=False)
-        download_file('https://github.com/SeleniumHQ/selenium/releases/download/selenium-4.7.0/selenium-server-4.7.2.jar')
-        click.secho("OK", fg='green')
-
-    except FileExistsError:
-        click.secho("Error", fg='red')
-        click.secho("Directory 'selenium' already exist!", fg='red')
-        sys.exit(1)
-
-
-def install_webdriver(browser):
-    chromedriver = "https://chromedriver.storage.googleapis.com/108.0.5359.71/chromedriver_linux64.zip"
-    geckodriver = "https://github.com/mozilla/geckodriver/releases/download/v0.32.0/geckodriver-v0.32.0-linux64.tar.gz"
-    try:
-        click.echo(f"Downloading driver for browser {browser}...", nl=False)
-        if browser == "chrome":
-            download_file(chromedriver)
-        elif browser == "firefox":
-            download_file(geckodriver)
-            file = tarfile.open('geckodriver-v0.32.0-linux64.tar.gz')
-            file.extractall('.')
-
-        click.secho("OK", fg='green')
-    except FileNotFoundError as e:
-        click.secho("Error", fg='red')
-        click.echo(e)
-
-
-@click.command(name='install:dev-server')
-@click.option('--browser', default='firefox', help='Browser which will be used for testing.')
-def install_selenium_dev_server(browser):
-    install_selenium()
-    install_webdriver(browser)
-    click.secho("Installation complete.", fg='green')
-    click.secho(f"INFO: Before running your Selenium Server locally, make sure that your {browser} browser is updated "
-                f"to the last stable version!")

vigilant_kit-1.1.1/src/vgl_cli/utils.py

@@ -1,11 +0,0 @@
-import requests
-
-
-def download_file(url):
-    local_filename = url.split('/')[-1]
-    with requests.get(url, stream=True) as r:
-        r.raise_for_status()
-        with open(local_filename, 'wb') as f:
-            for chunk in r.iter_content(chunk_size=8192):
-                f.write(chunk)
-    return local_filename

vigilant_kit-1.1.1/src/vgl_cli/vgl.py

@@ -1,13 +0,0 @@
-#!/usr/bin/env python
-
-import click
-from .local_dev import install_selenium_dev_server
-
-
-@click.group(name="vgl.py")
-def vgl():
-    pass
-
-
-vgl.add_command(install_selenium_dev_server)
-vgl()