Adding upstream version 0.12.0.

Signed-off-by: Daniel Baumann <daniel@debian.org>

tests/data/arista_test.xml

@@ -0,0 +1,25 @@
+
+<?xml version='1.0' encoding='UTF-8'?>
+<SoftwareImages>
+    <Image>
+        <version>4.28.3M</version>
+        <imageFile>EOS-4.28.3M.swi</imageFile>
+        <imageChecksum>abc123</imageChecksum>
+        <imageSize>1024000</imageSize>
+        <downloadPath>/path/to/4.28.3M</downloadPath>
+    </Image>
+    <Image>
+        <version>4.28.2F</version>
+        <imageFile>EOS-4.28.2F.swi</imageFile>
+        <imageChecksum>def456</imageChecksum>
+        <imageSize>1024000</imageSize>
+        <downloadPath>/path/to/4.28.2F</downloadPath>
+    </Image>
+    <Image>
+        <version>4.27.5M</version>
+        <imageFile>EOS-4.27.5M.swi</imageFile>
+        <imageChecksum>ghi789</imageChecksum>
+        <imageSize>1024000</imageSize>
+        <downloadPath>/path/to/4.27.5M</downloadPath>
+    </Image>
+</SoftwareImages>

tests/lib/dataset.py

@@ -106,12 +106,4 @@ eos_version = [
         "patch": 1,
         "rtype": "F",
     },
-    {
-        "version": "EOS-5.23.1F",
-        "is_valid": False,
-        "major": 4,
-        "minor": 23,
-        "patch": 1,
-        "rtype": "F",
-    },
 ]

tests/lib/fixtures.py

@@ -1,78 +1,21 @@
 #!/usr/bin/python
 # coding: utf-8 -*-
-# pylint: disable=logger-format-interpolation
-# pylint: disable=dangerous-default-value
-# flake8: noqa: W503
-# flake8: noqa: W1202
-
-from __future__ import absolute_import, division, print_function
-
-import os
-from typing import Any, Dict, List
+"""Fixtures for tests"""
 
 import pytest
+import os
+import xml.etree.ElementTree as ET
 
-import eos_downloader
-from tests.lib.dataset import (
-    eos_dataset_invalid,
-    eos_dataset_valid,
-    eos_token,
-    eos_token_invalid,
-)
+# Fixtures
+@pytest.fixture
+def xml_path() -> str:
+    """Fixture to provide path to test XML file"""
+    return os.path.join(os.path.dirname(os.path.dirname(__file__)), "data.xml")
 
 
 @pytest.fixture
-@pytest.mark.parametrize("DOWNLOAD_INFO", eos_dataset_valid)
-def create_download_instance(request, DOWNLOAD_INFO):
-    # logger.info("Execute fixture to create class elements")
-    request.cls.eos_downloader = eos_downloader.eos.EOSDownloader(
-        image=DOWNLOAD_INFO["image"],
-        software=DOWNLOAD_INFO["software"],
-        version=DOWNLOAD_INFO["version"],
-        token=eos_token,
-        hash_method="sha512sum",
-    )
-    yield
-    # logger.info('Cleanup test environment')
-    os.system("rm -f {}*".format(DOWNLOAD_INFO["filename"]))
-
-
-def generate_test_ids_dict(val: Dict[str, Any], key: str = "name") -> str:
-    """
-    generate_test_ids Helper to generate test ID for parametrize
-
-    Only related to SYSTEM_CONFIGLETS_TESTS structure
-
-    Parameters
-    ----------
-    val : dict
-        A configlet test structure
-
-    Returns
-    -------
-    str
-        Name of the configlet
-    """
-    if key in val.keys():
-        # note this wouldn't show any hours/minutes/seconds
-        return val[key]
-    return "undefined_test"
-
-
-def generate_test_ids_list(val: List[Dict[str, Any]], key: str = "name") -> str:
-    """
-    generate_test_ids Helper to generate test ID for parametrize
-
-    Only related to SYSTEM_CONFIGLETS_TESTS structure
-
-    Parameters
-    ----------
-    val : dict
-        A configlet test structure
-
-    Returns
-    -------
-    str
-        Name of the configlet
-    """
-    return [entry[key] if key in entry.keys() else "unset_entry" for entry in val]
+def xml_data():
+    xml_file = os.path.join(os.path.dirname(__file__), "data.xml")
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+    return root

tests/system/test_eos_download.py.old

@@ -1,47 +0,0 @@
-#!/usr/bin/python
-# coding: utf-8 -*-
-# pylint: disable=logger-format-interpolation
-# pylint: disable=dangerous-default-value
-# flake8: noqa: W503
-# flake8: noqa: W1202
-
-from __future__ import (absolute_import, division, print_function)
-import sys
-import os
-import platform
-from loguru import logger
-import pytest
-import eos_downloader
-from eos_downloader.eos import EOSDownloader
-from eos_downloader.data import DATA_MAPPING
-from tests.lib.dataset import eos_dataset_valid, eos_token, eos_token_invalid
-from tests.lib.fixtures import create_download_instance
-from tests.lib.helpers import default_filename
-
-
-# --------------------------------------------------------------- #
-# TEST CASES
-# --------------------------------------------------------------- #
-
-
-@pytest.mark.usefixtures("create_download_instance")
-@pytest.mark.parametrize("DOWNLOAD_INFO", eos_dataset_valid, ids=['EOS-sha512', 'EOS-md5' ,'vEOS-lab-no-hash'])
-@pytest.mark.eos_download
-class TestEosDownload_valid():
-    def test_data(self, DOWNLOAD_INFO):
-        print(str(DOWNLOAD_INFO))
-
-    @pytest.mark.dependency(name='authentication')
-    @pytest.mark.skipif(eos_token == eos_token_invalid, reason="Token is not set correctly")
-    @pytest.mark.skipif(platform.system() != 'Darwin', reason="Incorrect Hardware")
-    # @pytest.mark.xfail(reason="Deliberate - CI not set for testing AUTH")
-    @pytest.mark.webtest
-    def test_eos_download_authenticate(self):
-        assert self.eos_downloader.authenticate() is True
-
-    @pytest.mark.dependency(depends=["authentication"], scope='class')
-    @pytest.mark.webtest
-    @pytest.mark.slow
-    @pytest.mark.eos_download
-    def test_download_local(self, DOWNLOAD_INFO):
-        self.eos_downloader.download_local(file_path='.', checksum=DOWNLOAD_INFO['compute_checksum'])

tests/unit/cli/test_cli.py

@@ -0,0 +1,24 @@
+import pytest
+from click.testing import CliRunner
+from eos_downloader.cli.cli import ardl
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+def test_ardl_help(runner):
+    result = runner.invoke(ardl, ['--help'])
+    assert result.exit_code == 0
+    assert "Arista Network Download CLI" in result.output
+
+def test_ardl_version(runner):
+    result = runner.invoke(ardl, ['--version'])
+    assert result.exit_code == 0
+    assert "version" in result.output
+
+def test_cli_execution(runner):
+    result = runner.invoke(ardl, [])
+    assert result.exit_code == 0
+    assert "Usage: ardl [OPTIONS] COMMAND [ARGS]..." in result.output
+    assert "Arista Network Download CLI" in result.output
+

tests/unit/cli/test_debug.py

@@ -0,0 +1,13 @@
+
+import pytest
+from click.testing import CliRunner
+from eos_downloader.cli.cli import ardl
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+def test_debug_help(runner):
+    result = runner.invoke(ardl, ['debug', '--help'])
+    assert result.exit_code == 0
+    assert "Debug commands to work with ardl" in result.output

tests/unit/cli/test_get.py

@@ -0,0 +1,13 @@
+
+import pytest
+from click.testing import CliRunner
+from eos_downloader.cli.cli import ardl
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+def test_get_help(runner):
+    result = runner.invoke(ardl, ['get', '--help'])
+    assert result.exit_code == 0
+    assert "Download Arista from Arista website" in result.output

tests/unit/cli/test_info.py

@@ -0,0 +1,13 @@
+
+import pytest
+from click.testing import CliRunner
+from eos_downloader.cli.cli import ardl
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+def test_info_help(runner):
+    result = runner.invoke(ardl, ['info', '--help'])
+    assert result.exit_code == 0
+    assert "List information from Arista website" in result.output

tests/unit/logics/test_arista_server.py

@@ -0,0 +1,115 @@
+import pytest
+import requests
+from unittest.mock import patch, Mock
+from eos_downloader.logics.arista_server import AristaServer
+
+import eos_downloader.exceptions
+
+from tests.lib.fixtures import xml_path, xml_data
+
+@pytest.fixture
+def server():
+    return AristaServer(token="testtoken")
+
+
+def test_authenticate_success(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Success"},
+            "data": {"session_code": "testsessioncode"}
+        }
+        mock_post.return_value = mock_response
+
+        assert server.authenticate() is True
+        assert server._session_id is not None
+
+
+def test_authenticate_invalid_token(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Invalid access token"}
+        }
+        mock_post.return_value = mock_response
+
+        with pytest.raises(eos_downloader.exceptions.AuthenticationError):
+            server.authenticate()
+
+
+def test_authenticate_expired_token(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Access token expired"}
+        }
+        mock_post.return_value = mock_response
+
+        with pytest.raises(eos_downloader.exceptions.AuthenticationError):
+            server.authenticate()
+
+
+def test_authenticate_key_error(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Success"}
+        }
+        mock_post.return_value = mock_response
+
+        assert server.authenticate() is False
+        assert server._session_id is None
+
+
+def test_get_xml_data_success(server, xml_path):
+    with patch('requests.post') as mock_post:
+        with open(xml_path, 'r') as file:
+            xml_content = file.read()
+
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Success"},
+            "data": {"xml": xml_content},
+        }
+        mock_post.return_value = mock_response
+
+        xml_data = server.get_xml_data()
+        assert xml_data is not None
+        assert (
+            xml_data.getroot().tag == "cvpFolderList"
+        )  # Assuming the root tag in data.xml is 'cvpFolderList'
+
+
+def test_get_xml_data_key_error(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {}
+        mock_post.return_value = mock_response
+
+        with pytest.raises(KeyError):
+            server.get_xml_data()
+
+
+def test_get_url_success(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Success"},
+            "data": {"url": "http://example.com/download"},
+        }
+        mock_post.return_value = mock_response
+
+        url = server.get_url("remote/file/path")
+        assert url == "http://example.com/download"
+
+
+def test_get_url_no_data(server):
+    with patch('requests.post') as mock_post:
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "status": {"message": "Success"},
+        }
+        mock_post.return_value = mock_response
+
+        url = server.get_url("remote/file/path")
+        assert url is None

tests/unit/logics/test_arista_xml_server.py

@@ -0,0 +1,351 @@
+#!/usr/bin/python
+# coding: utf-8 -*-
+
+from __future__ import absolute_import, division, print_function
+
+import sys
+import os
+import pytest
+import logging
+from eos_downloader.models.version import EosVersion, CvpVersion
+from unittest.mock import patch
+from eos_downloader.logics.arista_xml_server import (
+    AristaXmlBase,
+    AristaXmlObject,
+    EosXmlObject,
+    AristaXmlQuerier
+)
+import xml.etree.ElementTree as ET
+
+
+# Fixtures
+@pytest.fixture
+def xml_path() -> str:
+    """Fixture to provide path to test XML file"""
+    return os.path.join(os.path.dirname(os.path.dirname(__file__)), "../data.xml")
+
+
+@pytest.fixture
+def xml_data():
+    xml_file = os.path.join(os.path.dirname(__file__), "../data.xml")
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+    return root
+
+
+# ------------------- #
+# Tests AristaXmlBase
+# ------------------- #
+def test_arista_xml_base_initialization(xml_path):
+    arista_xml_base = AristaXmlBase(xml_path=str(xml_path))
+    assert arista_xml_base.xml_data.getroot().tag == "cvpFolderList", (
+        f"Root tag should be 'cvpFolderList' but got"
+    )
+
+# ---------------------- #
+# Tests AristaXmlQuerier
+# ---------------------- #
+
+# ---------------------- #
+# Tests AristaXmlQuerier available_public_versions for eos
+
+def test_AristaXmlQuerier_available_public_versions_eos(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos")
+    assert len(versions) == 309, "Incorrect number of versions"
+    assert versions[0] == EosVersion().from_str("4.33.0F"), "First version should be 4.33.0F - got {versions[0]}"
+
+
+def test_AristaXmlQuerier_available_public_versions_eos_f_release(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos", rtype="F")
+    assert len(versions) == 95, "Incorrect number of versions: got {len(versions)} expected 207"
+    assert versions[0] == EosVersion().from_str(
+        "4.33.0F"
+    ), "First version should be 4.33.0F - got {len(versions)}"
+
+
+def test_AristaXmlQuerier_available_public_versions_eos_m_release(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos", rtype="M")
+    assert (
+        len(versions) == 207
+    ), "Incorrect number of versions: got {len(versions)} expected 207"
+    assert versions[0] == EosVersion().from_str(
+        "4.32.3M"
+    ), "First version should be 4.32.3M - got {versions[0]}"
+
+def test_AristaXmlQuerier_available_public_versions_eos_branch_4_29(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos", branch="4.29")
+    assert len(versions) == 34, "Incorrect number of versions"
+    for version in versions:
+        # logging.debug(f"Checking version {version}")
+        assert version.is_in_branch("4.29"), f"Version {version} is not in branch 4.29"
+    assert versions[0] == EosVersion().from_str("4.29.10M"), "First version should be 4.29.10M - got {versions[0]}"
+
+
+def test_AristaXmlQuerier_available_public_versions_eos_f_release_branch_4_29(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos", rtype="F", branch="4.29")
+    assert len(versions) == 6, "Incorrect number of versions - expected 6"
+    for version in versions:
+        # logging.debug(f"Checking version {version}")
+        assert version.is_in_branch("4.29"), f"Version {version} is not in branch 4.29"
+    assert versions[0] == EosVersion().from_str(
+        "4.29.2F"
+    ), "First version should be 4.29.2F - got {versions[0]}"
+
+
+def test_AristaXmlQuerier_available_public_versions_eos_m_release_branch_4_29(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="eos", rtype="M", branch="4.29")
+    assert len(versions) == 28, "Incorrect number of versions - expected 28"
+    for version in versions:
+        # logging.debug(f"Checking version {version}")
+        assert version.is_in_branch("4.29"), f"Version {version} is not in branch 4.29"
+    assert versions[0] == EosVersion().from_str(
+        "4.29.10M"
+    ), "First version should be 4.29.10M - got {versions[0]}"
+
+
+# ---------------------- #
+# Tests AristaXmlQuerier available_public_versions for cvp
+
+
+def test_AristaXmlQuerier_available_public_versions_cvp(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.available_public_versions(package="cvp")
+    assert (
+        len(versions) == 12
+    ), "Incorrect number of versions: got {len(versions)} expected 12"
+    assert versions[0] == CvpVersion().from_str(
+        "2024.3.0"
+    ), "First version should be 2024.3.0 - got {versions[0]}"
+
+
+# ---------------------- #
+# Tests AristaXmlQuerier branches for eos
+
+
+def test_AristaXmlQuerier_branch_eos(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.branches(package="eos")
+    assert len(versions) == 14, "Incorrect number of branches, got {len(versions)} expected 14"
+    assert EosVersion().from_str("4.33.0F").branch in versions, "4.33 should be in branches {versions}"
+
+
+def test_AristaXmlQuerier_branch_eos_latest(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.branches(package="eos", latest=True)
+    assert (
+        len(versions) == 1
+    ), "Incorrect number of branches, got {len(versions)} expected 1"
+    assert (
+        EosVersion().from_str("4.33.0F").branch in versions
+    ), "4.33 should be in branches {versions}"
+
+
+# ---------------------- #
+# Tests AristaXmlQuerier branches for cvp
+
+
+def test_AristaXmlQuerier_branch_cvp(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.branches(package="cvp")
+    assert (
+        len(versions) == 5
+    ), "Incorrect number of branches, got {len(versions)} expected 5"
+    assert (
+        CvpVersion().from_str("2024.3.0").branch in versions
+    ), "2024.3 should be in branches {versions}"
+
+
+def test_AristaXmlQuerier_branch_cvp_latest(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.branches(package="cvp", latest=True)
+    assert (
+        len(versions) == 1
+    ), "Incorrect number of branches, got {len(versions)} expected 1"
+    assert (
+        CvpVersion().from_str("2024.3.0").branch in versions
+    ), "2024.3 should be in branches {versions}"
+
+
+# ---------------------- #
+# Tests AristaXmlQuerier latest for eos
+
+
+def test_AristaXmlQuerier_latest_eos(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="eos")
+    assert (
+        EosVersion().from_str("4.33.0F") == versions
+    ), "4.33.0F should be the latest, got {versions}"
+
+
+def test_AristaXmlQuerier_latest_eos_f_release(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="eos", rtype="F")
+    assert (
+        EosVersion().from_str("4.33.0F") == versions
+    ), "4.33.0F should be the latest, got {versions}"
+
+
+def test_AristaXmlQuerier_latest_eos_m_release(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="eos", rtype="M")
+    assert (
+        EosVersion().from_str("4.32.3M") == versions
+    ), "4.32.3M should be the latest, got {versions}"
+
+
+def test_AristaXmlQuerier_latest_eos_f_release_branch_4_29(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="eos", rtype="F", branch="4.29")
+    assert (
+        EosVersion().from_str("4.29.2F") == versions
+    ), "4.29.2F should be the latest, got {versions}"
+
+
+def test_AristaXmlQuerier_latest_eos_m_release_branch_4_29(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="eos", rtype="M", branch="4.29")
+    assert (
+        EosVersion().from_str("4.29.10M") == versions
+    ), "4.29.10M should be the latest, got {versions}"
+
+
+# ---------------------- #
+# Tests AristaXmlQuerier latest for cvp
+
+
+def test_AristaXmlQuerier_latest_cvp(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="cvp")
+    assert (
+        CvpVersion().from_str("2024.3.0") == versions
+    ), "2024.3.0 should be the latest, got {versions}"
+
+
+def test_AristaXmlQuerier_latest_cvp(xml_path):
+    xml_querier = AristaXmlQuerier(xml_path=xml_path)
+    versions = xml_querier.latest(package="cvp", branch="2024.2")
+    assert (
+        CvpVersion().from_str("2024.2.1") == versions
+    ), "2024.2.1 should be the latest, got {versions}"
+
+
+# ---------------------- #
+# Tests AristaXmlObject
+# ---------------------- #
+
+def test_arista_xml_object_initialization(xml_path):
+    arista_xml_object = AristaXmlObject(searched_version="4.29.2F", image_type="image", xml_path=xml_path)
+    assert arista_xml_object.search_version == "4.29.2F", "Incorrect search version"
+    assert arista_xml_object.image_type == "image", "Incorrect image type"
+
+def test_arista_xml_object_filename_for_ceos(xml_path):
+    arista_xml_object = EosXmlObject(
+        searched_version="4.29.2F",
+        image_type="cEOS",
+        xml_path=xml_path,
+    )
+    filename = arista_xml_object.filename
+    assert filename == "cEOS-lab-4.29.2F.tar.xz", f"Incorrect filename, got {filename}"
+
+def test_arista_xml_object_hashfile(xml_path):
+    arista_xml_object = EosXmlObject(
+        searched_version="4.29.2F",
+        image_type="cEOS",
+        xml_path=xml_path,
+    )
+    hashfile = arista_xml_object.hash_filename()
+    assert (
+        hashfile == "cEOS-lab-4.29.2F.tar.xz.sha512sum"
+    ), f"Incorrect hashfile, got {hashfile}"
+    hashfile = arista_xml_object.hash_filename()
+    assert (
+        hashfile == "cEOS-lab-4.29.2F.tar.xz.sha512sum"
+    ), f"Incorrect hashfile, got {hashfile}"
+
+def test_arista_xml_object_path_from_xml(xml_path):
+    arista_xml_object = EosXmlObject(
+        searched_version="4.29.2F",
+        image_type="cEOS",
+        xml_path=xml_path,
+    )
+    path = arista_xml_object.path_from_xml(search_file="EOS-4.29.2F.swi")
+    assert (
+        path
+        == "/support/download/EOS-USA/Active Releases/4.29/EOS-4.29.2F/EOS-4.29.2F.swi"
+    ), f"Incorrect path, got {path}"
+
+def test_arista_xml_object_url(xml_path):
+    with patch('eos_downloader.logics.arista_xml_server.AristaXmlObject._url') as mock_url:
+        mock_url.return_value = "https://testserver.com/path/to/EOS-4.29.2F.swi"
+        arista_xml_object = EosXmlObject(
+            searched_version="4.29.2F",
+            image_type="cEOS",
+            xml_path=xml_path,
+        )
+        url = arista_xml_object._url(xml_path="/path/to/EOS-4.29.2F.swi")
+        assert url == "https://testserver.com/path/to/EOS-4.29.2F.swi", f"Incorrect URL, got {url}"
+
+def test_arista_xml_object_urls(xml_path):
+    with patch(
+        "eos_downloader.logics.arista_xml_server.AristaXmlObject._url"
+    ) as mock_url:
+        mock_url.side_effect = [
+            "https://arista.com/path/to/EOS-4.29.2F.swi",
+            "https://arista.com/path/to/EOS-4.29.2F.swi.sha512sum"
+        ]
+        arista_xml_object = EosXmlObject(
+            searched_version="4.29.2F",
+            image_type="default",
+            xml_path=xml_path,
+        )
+        urls = arista_xml_object.urls
+        logging.warning(f"URLs are: {urls}")
+        expected_urls = {
+            "image": "https://arista.com/path/to/EOS-4.29.2F.swi",
+            "sha512sum": "https://arista.com/path/to/EOS-4.29.2F.swi.sha512sum"
+        }
+        assert urls == expected_urls, f"Incorrect URLs, got {urls}"
+
+def test_arista_xml_object_urls_with_invalid_hash(xml_path):
+    with patch(
+        "eos_downloader.logics.arista_xml_server.AristaXmlObject._url"
+    ) as mock_url:
+        mock_url.side_effect = [
+            "https://arista.com/path/to/EOS-4.29.2F.swi",
+            "https://arista.com/path/to/EOS-4.29.2F.swi.sha512sum"
+        ]
+        arista_xml_object = EosXmlObject(
+            searched_version="4.29.2F",
+            image_type="default",
+            xml_path=xml_path,
+        )
+        urls = arista_xml_object.urls
+        expected_urls = {
+            "image": "https://arista.com/path/to/EOS-4.29.2F.swi",
+            "sha512sum": "https://arista.com/path/to/EOS-4.29.2F.swi.sha512sum"
+        }
+        assert urls == expected_urls, f"Incorrect URLs, got {urls}"
+
+def test_arista_xml_object_urls_with_missing_files(xml_path):
+    with patch(
+        "eos_downloader.logics.arista_xml_server.AristaXmlObject._url"
+    ) as mock_url:
+        mock_url.side_effect = [None, None, None]
+        arista_xml_object = EosXmlObject(
+            searched_version="4.29.2F",
+            image_type="default",
+            xml_path=xml_path,
+        )
+        urls = arista_xml_object.urls
+        expected_urls = {
+            "image": None,
+            "sha512sum": None
+        }
+        assert urls == expected_urls, f"Incorrect URLs, got {urls}"

tests/unit/logics/test_download.py

@@ -0,0 +1,143 @@
+import os
+import pytest
+from unittest.mock import Mock, patch, mock_open
+from eos_downloader.logics.download import SoftManager
+from eos_downloader.logics.arista_xml_server import EosXmlObject
+
+
+@pytest.fixture
+def soft_manager():
+    return SoftManager()
+
+
+@pytest.fixture
+def mock_eos_object():
+    mock = Mock(spec=EosXmlObject)
+    mock.version = "4.28.0F"
+    mock.filename = "EOS-4.28.0F.swi"
+    mock.urls = {
+        "image": "http://example.com/EOS-4.28.0F.swi",
+        "md5sum": "http://example.com/EOS-4.28.0F.swi.md5",
+        "sha512sum": "http://example.com/EOS-4.28.0F.swi.sha512",
+    }
+    mock.hash_filename = Mock(return_value="EOS-4.28.0F.swi.md5")
+    return mock
+
+
+@pytest.mark.parametrize("dry_run", [True, False])
+def test_soft_manager_init(dry_run):
+    manager = SoftManager(dry_run=dry_run)
+    assert manager.dry_run == dry_run
+    assert manager.file == {"name": None, "md5sum": None, "sha512sum": None}
+
+
+@patch("requests.get")
+@patch("tqdm.tqdm")
+def test_download_file_raw(mock_tqdm, mock_requests):
+    # Setup mock response
+    mock_response = Mock()
+    mock_response.headers = {"Content-Length": "1024"}
+    mock_response.iter_content.return_value = [b"data"]
+    mock_requests.return_value = mock_response
+
+    with patch("builtins.open", mock_open()) as mock_file:
+        result = SoftManager._download_file_raw("http://test.com/file", "/tmp/file")
+        assert result == "/tmp/file"
+        mock_file().write.assert_called_with(b"data")
+
+
+@patch("os.makedirs")
+def test_create_destination_folder(mock_makedirs):
+    SoftManager._create_destination_folder("/test/path")
+    mock_makedirs.assert_called_once_with("/test/path", exist_ok=True)
+
+
+def test_compute_hash_md5sum(soft_manager):
+    test_data = b"test data"
+    expected_hash = "eb733a00c0c9d336e65691a37ab54293"
+
+    with patch("builtins.open", mock_open(read_data=test_data)):
+        result = soft_manager._compute_hash_md5sum("test_file", expected_hash)
+        assert result is True
+
+        # Test with incorrect hash
+        result = soft_manager._compute_hash_md5sum("test_file", "wrong_hash")
+        assert result is False
+
+
+# @pytest.mark.parametrize(
+#     "check_type,valid_hash", [("md5sum", True), ("sha512sum", True)]
+# )
+# def test_checksum(soft_manager, check_type, valid_hash):
+#     soft_manager.file = {
+#         "name": "test.swi",
+#         "md5sum": "test.swi.md5",
+#         "sha512sum": "test.swi.sha512",
+#     }
+
+#     mock_hash = "a" * (128 if check_type == "sha512sum" else 32)
+
+#     with patch(
+#         "builtins.open",
+#         mock_open(read_data=f"{mock_hash if valid_hash else 'wrong'} test.swi"),
+#     ) as mock_file:
+#         if valid_hash:
+#             with patch(
+#                 "hashlib.sha512" if check_type == "sha512sum" else "hashlib.md5"
+#             ) as mock_hash_func:
+#                 mock_hash_instance = Mock()
+#                 mock_hash_instance.hexdigest.return_value = mock_hash
+#                 mock_hash_func.return_value = mock_hash_instance
+#                 assert soft_manager.checksum(check_type) is True
+#         else:
+#             with pytest.raises(ValueError):
+#                 soft_manager.checksum(check_type)
+
+
+@patch("eos_downloader.logics.download.SoftManager._download_file_raw")
+@patch("eos_downloader.helpers.DownloadProgressBar")
+def test_download_file(mock_progress_bar, mock_download_raw, soft_manager):
+    url = "http://test.com/file"
+    file_path = "/tmp"
+    filename = "test.swi"
+
+    # Test with rich interface
+    result = soft_manager.download_file(url, file_path, filename, rich_interface=True)
+    assert result == os.path.join(file_path, filename)
+    mock_progress_bar.assert_called_once()
+
+
+@patch("eos_downloader.logics.download.SoftManager.download_file")
+def test_downloads(mock_download, soft_manager, mock_eos_object):
+    result = soft_manager.downloads(
+        mock_eos_object, "/tmp/downloads", rich_interface=True
+    )
+    assert result == "/tmp/downloads"
+    assert mock_download.call_count == len(mock_eos_object.urls)
+
+
+@patch("shutil.which")
+@patch("os.system")
+def test_import_docker(mock_system, mock_which, soft_manager):
+    mock_which.return_value = "/usr/bin/docker"
+
+    # Test with existing file
+    with patch("os.path.exists", return_value=True):
+        soft_manager.import_docker("/tmp/test.swi", "arista/ceos", "latest")
+        mock_system.assert_called_once()
+
+    # Test with non-existing file
+    with patch("os.path.exists", return_value=False):
+        with pytest.raises(FileNotFoundError):
+            soft_manager.import_docker("/tmp/nonexistent.swi")
+
+
+@patch("os.system")
+@patch("os.path.exists")
+def test_provision_eve(mock_exists, mock_system, soft_manager, mock_eos_object):
+    mock_exists.return_value = False
+
+    with patch("eos_downloader.logics.download.SoftManager.download_file"):
+        soft_manager.provision_eve(mock_eos_object, noztp=False)
+        # Check if qemu-img convert and unl_wrapper commands were called
+        assert mock_system.call_count == 2

tests/unit/models/test_data.py

@@ -0,0 +1,47 @@
+# coding: utf-8 -*-
+"""Tests for the eos_downloader.models.data.DataMapping class."""
+
+import pytest
+
+from eos_downloader.models.data import DataMapping, ImageInfo
+
+
+@pytest.fixture
+def data_mapping():
+    return DataMapping(
+        CloudVision={"ova": ImageInfo(extension=".ova", prepend="cvp" )},
+        EOS={
+            "64": ImageInfo(extension=".swi", prepend="EOS64"),
+            "default": ImageInfo(extension=".swi", prepend="EOS" ),
+        },
+    )
+
+
+def test_filename_valid_cloudvision(data_mapping):
+    result = data_mapping.filename("CloudVision", "ova", "1.2.3")
+    assert result == "cvp-1.2.3.ova"
+
+
+def test_filename_valid_eos(data_mapping):
+    result = data_mapping.filename("EOS", "64", "4.28.0F")
+    assert result == "EOS64-4.28.0F.swi"
+
+
+def test_filename_eos_default(data_mapping):
+    with pytest.raises(ValueError) as exc_info:
+        data_mapping.filename("EOS", "unknown", "4.28.0F")
+    assert str(exc_info.value) == "No default configuration found for image type unknown"
+
+
+def test_filename_invalid_software(data_mapping):
+    with pytest.raises(
+        ValueError, match="Incorrect value for software InvalidSoftware"
+    ):
+        data_mapping.filename("InvalidSoftware", "ova", "1.2.3")
+
+
+def test_filename_invalid_type_no_default(data_mapping):
+    with pytest.raises(
+        ValueError, match="No default configuration found for image type invalid"
+    ):
+        data_mapping.filename("CloudVision", "invalid", "1.2.3")

tests/unit/models/test_version.py

@@ -0,0 +1,99 @@
+# coding: utf-8 -*-
+"""Tests for the eos_downloader.models.version module."""
+
+import sys
+import pytest
+from loguru import logger
+from eos_downloader.models.version import SemVer, EosVersion, CvpVersion
+
+logger.remove()
+logger.add(sys.stderr, level="DEBUG")
+
+
+def test_semver_from_str():
+    version = SemVer.from_str("4.23.3M")
+    assert version.major == 4
+    assert version.minor == 23
+    assert version.patch == 3
+    assert version.rtype == "M"
+
+def test_semver_str():
+    version = SemVer(major=4, minor=23, patch=3, rtype="M")
+    assert str(version) == "4.23.3M"
+
+def test_semver_branch():
+    version = SemVer(major=4, minor=23, patch=3, rtype="M")
+    assert version.branch == "4.23"
+
+def test_semver_comparison():
+    version1 = SemVer(major=4, minor=23, patch=3, rtype="M")
+    version2 = SemVer.from_str("4.24.1F")
+    assert version1 < version2
+    assert version1 != version2
+    assert version2 > version1
+    assert version1 <= version2
+    assert version2 >= version1
+
+def test_semver_match():
+    version = SemVer.from_str("4.23.3M")
+    assert version.match("<=4.23.3M")
+    assert not version.match("==4.24.0F")
+
+def test_semver_is_in_branch():
+    version = SemVer.from_str("4.23.3M")
+    assert version.is_in_branch("4.23")
+    assert not version.is_in_branch("4.24")
+
+def test_eosversion_from_str():
+    version = EosVersion.from_str("4.32.1F")
+    assert version.major == 4
+    assert version.minor == 32
+    assert version.patch == 1
+    assert version.rtype == "F"
+
+def test_cvpversion_from_str():
+    version = CvpVersion.from_str("2024.1.0")
+    assert version.major == 2024
+    assert version.minor == 1
+    assert version.patch == 0
+    assert version.rtype is None
+
+def test_semver_invalid_str():
+    version = SemVer.from_str("invalid.version")
+    assert version.major == 0
+    assert version.minor == 0
+    assert version.patch == 0
+    assert version.rtype is None
+
+def test_semver_compare_invalid_type():
+    version = SemVer(major=4, minor=23, patch=3, rtype="M")
+    with pytest.raises(ValueError):
+        version._compare("invalid")
+
+def test_eosversion_invalid_str():
+    version = EosVersion.from_str("invalid.version")
+    assert version.major == 0
+    assert version.minor == 0
+    assert version.patch == 0
+    assert version.rtype is None
+
+def test_cvpversion_invalid_str():
+    version = CvpVersion.from_str("invalid.version")
+    assert version.major == 0
+    assert version.minor == 0
+    assert version.patch == 0
+    assert version.rtype is None
+
+def test_semver_match_invalid_operator():
+    version = SemVer.from_str("4.23.3M")
+    with pytest.raises(ValueError):
+        version.match("+=4.23.3M")
+
+def test_semver_is_in_branch_invalid():
+    version = SemVer.from_str("4.23.3M")
+    assert not version.is_in_branch("invalid.branch")
+
+def test_semver_compare_none():
+    version1 = SemVer(major=4, minor=23, patch=3, rtype="M")
+    version2 = SemVer(major=4, minor=23, patch=3, rtype=None)
+    assert version1._compare(version2) == 0

tests/unit/test_eos_version.py

@@ -1,170 +0,0 @@
-#!/usr/bin/python
-# coding: utf-8 -*-
-# pylint: disable=logger-format-interpolation
-# pylint: disable=dangerous-default-value
-# flake8: noqa: W503
-# flake8: noqa: W1202
-
-from __future__ import absolute_import, division, print_function
-
-import sys
-
-import pytest
-from loguru import logger
-
-from eos_downloader.models.version import BASE_VERSION_STR, EosVersion
-from tests.lib.dataset import eos_version
-from tests.lib.fixtures import generate_test_ids_list
-
-logger.remove()
-logger.add(sys.stderr, level="DEBUG")
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_from_str(EOS_VERSION):
-    version = EosVersion.from_str(EOS_VERSION["version"])
-    if EOS_VERSION["is_valid"]:
-        assert version.major == EOS_VERSION["major"]
-        assert version.minor == EOS_VERSION["minor"]
-        assert version.patch == EOS_VERSION["patch"]
-        assert version.rtype == EOS_VERSION["rtype"]
-    else:
-        assert str(version) == BASE_VERSION_STR
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_to_str(EOS_VERSION):
-    version = EosVersion(**EOS_VERSION)
-    if EOS_VERSION["is_valid"]:
-        assert version.major == EOS_VERSION["major"]
-        assert version.minor == EOS_VERSION["minor"]
-        assert version.patch == EOS_VERSION["patch"]
-        assert version.rtype == EOS_VERSION["rtype"]
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_branch(EOS_VERSION):
-    if EOS_VERSION["is_valid"]:
-        version = EosVersion(**EOS_VERSION)
-        assert version.branch == f'{EOS_VERSION["major"]}.{EOS_VERSION["minor"]}'
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_eq_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    logger.warning(f"version is: {version.dict()}")
-    assert version == version
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_ge_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    version_b = EosVersion.from_str(BASE_VERSION_STR)
-    assert version >= version_b
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_gs_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    version_b = EosVersion.from_str(BASE_VERSION_STR)
-    assert version > version_b
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_le_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    version_b = EosVersion.from_str(BASE_VERSION_STR)
-    assert version_b <= version
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_ls_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    version_b = EosVersion.from_str(BASE_VERSION_STR)
-    assert version_b < version
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_ne_operator(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    version_b = EosVersion.from_str(BASE_VERSION_STR)
-    assert version_b != version
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_match(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    assert version.match(f'=={EOS_VERSION["version"]}')
-    assert version.match(f"!={BASE_VERSION_STR}")
-    assert version.match(f">={BASE_VERSION_STR}")
-    assert version.match(f">{BASE_VERSION_STR}")
-    assert version.match("<=4.99.0F")
-    assert version.match("<4.99.0F")
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_is_in_branch(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    version = EosVersion(**EOS_VERSION)
-    assert version.is_in_branch(f"{EOS_VERSION['major']}.{EOS_VERSION['minor']}")
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_match_exception(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    with pytest.raises(Exception) as e_info:
-        version = EosVersion(**EOS_VERSION)
-        assert version.match(f'+={EOS_VERSION["version"]}')
-        logger.info(f"receive exception: {e_info}")
-
-
-@pytest.mark.parametrize(
-    "EOS_VERSION", eos_version, ids=generate_test_ids_list(eos_version, key="version")
-)
-def test_eos_version_compare_exception(EOS_VERSION):
-    if not EOS_VERSION["is_valid"]:
-        pytest.skip("not a valid version to test")
-    with pytest.raises(Exception) as e_info:
-        version = EosVersion(**EOS_VERSION)
-        version._compare(BASE_VERSION_STR)
-        logger.info(f"receive exception: {e_info}")

tests/unit/test_object_downloader.py

@@ -1,163 +0,0 @@
-#!/usr/bin/python
-# coding: utf-8 -*-
-# pylint: disable=logger-format-interpolation
-# pylint: disable=dangerous-default-value
-# flake8: noqa: W503
-# flake8: noqa: W1202
-
-# import platform
-import sys
-
-import pytest
-from loguru import logger
-
-import eos_downloader
-from eos_downloader.data import DATA_MAPPING
-from eos_downloader.eos import EOSDownloader
-from tests.lib.dataset import (
-    eos_dataset_invalid,
-    eos_dataset_valid,
-    eos_token,
-    eos_token_invalid,
-)
-from tests.lib.fixtures import create_download_instance
-from tests.lib.helpers import default_filename, is_on_github_actions
-
-logger.remove()
-logger.add(sys.stderr, level="DEBUG")
-
-
-@pytest.mark.usefixtures("create_download_instance")
-@pytest.mark.parametrize(
-    "DOWNLOAD_INFO",
-    eos_dataset_valid,
-    ids=["EOS-sha512", "EOS-md5", "vEOS-lab-no-hash"],
-)
-@pytest.mark.eos_download
-class TestEosDownload_valid:
-    def test_data(self, DOWNLOAD_INFO):
-        logger.info(f"test input: {DOWNLOAD_INFO}")
-        logger.info(f"test build: {self.eos_downloader.__dict__}")
-
-    def test_eos_download_create(self, DOWNLOAD_INFO):
-        my_download = eos_downloader.eos.EOSDownloader(
-            image=DOWNLOAD_INFO["image"],
-            software=DOWNLOAD_INFO["software"],
-            version=DOWNLOAD_INFO["version"],
-            token=eos_token,
-            hash_method="sha512sum",
-        )
-        logger.info(my_download)
-        assert isinstance(my_download, eos_downloader.eos.EOSDownloader)
-
-    def test_eos_download_repr_string(self, DOWNLOAD_INFO):
-        expected = f"{DOWNLOAD_INFO['software']} - {DOWNLOAD_INFO['image']} - {DOWNLOAD_INFO['version']}"
-        logger.info(self.eos_downloader)
-        assert str(self.eos_downloader) == expected
-
-    def test_eos_download_build_filename(self, DOWNLOAD_INFO):
-        assert self.eos_downloader._build_filename() == DOWNLOAD_INFO["filename"]
-
-    @pytest.mark.dependency(name="authentication")
-    @pytest.mark.skipif(
-        eos_token == eos_token_invalid, reason="Token is not set correctly"
-    )
-    @pytest.mark.skipif(is_on_github_actions(), reason="Running on Github Runner")
-    # @pytest.mark.xfail(reason="Deliberate - CI not set for testing AUTH")
-    @pytest.mark.webtest
-    def test_eos_download_authenticate(self):
-        assert self.eos_downloader.authenticate() is True
-
-    @pytest.mark.dependency(depends=["authentication"], scope="class")
-    @pytest.mark.webtest
-    def test_eos_download_get_remote_file_path(self, DOWNLOAD_INFO):
-        assert (
-            self.eos_downloader._get_remote_filepath() == DOWNLOAD_INFO["remote_path"]
-        )
-
-    @pytest.mark.dependency(depends=["authentication"], scope="class")
-    @pytest.mark.webtest
-    def test_eos_download_get_file_url(self, DOWNLOAD_INFO):
-        url = self.eos_downloader._get_url(
-            remote_file_path=DOWNLOAD_INFO["remote_path"]
-        )
-        logger.info(url)
-        assert "https://downloads.arista.com/EOS-USA/Active%20Releases/" in url
-
-
-@pytest.mark.usefixtures("create_download_instance")
-@pytest.mark.parametrize("DOWNLOAD_INFO", eos_dataset_invalid, ids=["EOS-FAKE"])
-class TestEosDownload_invalid:
-    def test_data(self, DOWNLOAD_INFO):
-        logger.info(f"test input: {dict(DOWNLOAD_INFO)}")
-        logger.info(f"test build: {self.eos_downloader.__dict__}")
-
-    def test_eos_download_login_error(self, DOWNLOAD_INFO):
-        my_download = eos_downloader.eos.EOSDownloader(
-            image=DOWNLOAD_INFO["image"],
-            software=DOWNLOAD_INFO["software"],
-            version=DOWNLOAD_INFO["version"],
-            token=eos_token_invalid,
-            hash_method=DOWNLOAD_INFO["expected_hash"],
-        )
-        assert my_download.authenticate() is False
-
-    @pytest.mark.dependency(name="authentication")
-    @pytest.mark.skipif(
-        eos_token == eos_token_invalid, reason="Token is not set correctly"
-    )
-    @pytest.mark.skipif(is_on_github_actions(), reason="Running on Github Runner")
-    # @pytest.mark.xfail(reason="Deliberate - CI not set for testing AUTH")
-    @pytest.mark.webtest
-    def test_eos_download_authenticate(self):
-        assert self.eos_downloader.authenticate() is True
-
-    # SOFTWARE/PLATFORM TESTING
-
-    # @pytest.mark.skip(reason="Not yet implemented in lib")
-    def test_eos_file_name_with_incorrect_software(self, DOWNLOAD_INFO):
-        self.eos_downloader.software = "FAKE"
-        logger.info(f"test build: {self.eos_downloader.__dict__}")
-        with pytest.raises(ValueError) as e_info:
-            result = self.eos_downloader._build_filename()
-            logger.info(f"receive exception: {e_info}")
-            self.eos_downloader.software = DOWNLOAD_INFO["software"]
-
-    @pytest.mark.webtest
-    @pytest.mark.dependency(depends=["authentication"], scope="class")
-    def test_eos_download_get_remote_file_path_for_invlaid_software(
-        self, DOWNLOAD_INFO
-    ):
-        self.eos_downloader.software = "FAKE"
-        logger.info(f"Platform set to: {self.eos_downloader.software}")
-        logger.info(f"test build: {self.eos_downloader.__dict__}")
-        with pytest.raises(ValueError) as e_info:
-            result = self.eos_downloader._build_filename()
-            logger.info(f"receive exception: {e_info}")
-        self.eos_downloader.software = DOWNLOAD_INFO["software"]
-
-    # IMAGE TESTING
-
-    def test_eos_file_name_with_incorrect_image(self, DOWNLOAD_INFO):
-        self.eos_downloader.image = "FAKE"
-        logger.info(f"Image set to: {self.eos_downloader.image}")
-        assert DOWNLOAD_INFO["filename"] == self.eos_downloader._build_filename()
-        self.eos_downloader.software == DOWNLOAD_INFO["image"]
-
-    @pytest.mark.webtest
-    @pytest.mark.dependency(depends=["authentication"], scope="class")
-    def test_eos_download_get_remote_file_path_for_invlaid_image(self, DOWNLOAD_INFO):
-        self.eos_downloader.image = "FAKE"
-        logger.info(f"Image set to: {self.eos_downloader.image}")
-        assert self.eos_downloader.authenticate() is True
-        assert DOWNLOAD_INFO["filename"] == self.eos_downloader._build_filename()
-        self.eos_downloader.image = DOWNLOAD_INFO["image"]
-
-    # VERSION TESTING
-
-    @pytest.mark.webtest
-    @pytest.mark.dependency(depends=["authentication"], scope="class")
-    def test_eos_download_get_remote_file_path_for_invlaid_version(self, DOWNLOAD_INFO):
-        self.eos_downloader.version = "FAKE"
-        logger.info(f"Version set to: {self.eos_downloader.version}")
-        assert self.eos_downloader._get_remote_filepath() == ""