diff --git a/changes/365.added b/changes/365.added
new file mode 100644
index 00000000..b3d9ecf0
--- /dev/null
+++ b/changes/365.added
@@ -0,0 +1,2 @@
+Added the remote file copy feature to Arista EOS devices.
+Added unittests for remote file copy on Arista EOS devices.
\ No newline at end of file
diff --git a/poetry.lock b/poetry.lock
index 7f27b716..a83e0374 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.3.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.3.2 and should not be changed by hand.
 
 [[package]]
 name = "astroid"
@@ -736,6 +736,40 @@ files = [
     {file = "hjson-3.1.0.tar.gz", hash = "sha256:55af475a27cf83a7969c808399d7bccdec8fb836a07ddbd574587593b9cdcf75"},
 ]
 
+[[package]]
+name = "hypothesis"
+version = "6.151.12"
+description = "The property-based testing library for Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["dev"]
+files = [
+    {file = "hypothesis-6.151.12-py3-none-any.whl", hash = "sha256:37d4f3a768365c30571b11dfd7a6857a12173d933010b2c4ab65619f1b5952c5"},
+    {file = "hypothesis-6.151.12.tar.gz", hash = "sha256:be485f503979af4c3dfa19e3fc2b967d0458e7f8c4e28128d7e215e0a55102e0"},
+]
+
+[package.dependencies]
+exceptiongroup = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
+sortedcontainers = ">=2.1.0,<3.0.0"
+
+[package.extras]
+all = ["black (>=20.8b0)", "click (>=7.0)", "crosshair-tool (>=0.0.102)", "django (>=4.2)", "dpcontracts (>=0.4)", "hypothesis-crosshair (>=0.0.27)", "lark (>=0.10.1)", "libcst (>=0.3.16)", "numpy (>=1.21.6)", "pandas (>=1.1)", "pytest (>=4.6)", "python-dateutil (>=1.4)", "pytz (>=2014.1)", "redis (>=3.0.0)", "rich (>=9.0.0)", "tzdata (>=2025.3) ; sys_platform == \"win32\" or sys_platform == \"emscripten\"", "watchdog (>=4.0.0)"]
+cli = ["black (>=20.8b0)", "click (>=7.0)", "rich (>=9.0.0)"]
+codemods = ["libcst (>=0.3.16)"]
+crosshair = ["crosshair-tool (>=0.0.102)", "hypothesis-crosshair (>=0.0.27)"]
+dateutil = ["python-dateutil (>=1.4)"]
+django = ["django (>=4.2)"]
+dpcontracts = ["dpcontracts (>=0.4)"]
+ghostwriter = ["black (>=20.8b0)"]
+lark = ["lark (>=0.10.1)"]
+numpy = ["numpy (>=1.21.6)"]
+pandas = ["pandas (>=1.1)"]
+pytest = ["pytest (>=4.6)"]
+pytz = ["pytz (>=2014.1)"]
+redis = ["redis (>=3.0.0)"]
+watchdog = ["watchdog (>=4.0.0)"]
+zoneinfo = ["tzdata (>=2025.3) ; sys_platform == \"win32\" or sys_platform == \"emscripten\""]
+
 [[package]]
 name = "idna"
 version = "3.11"
@@ -2065,6 +2099,18 @@ files = [
     {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"},
 ]
 
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+description = "Sorted Containers -- Sorted List, Sorted Dict, Sorted Set"
+optional = false
+python-versions = "*"
+groups = ["dev"]
+files = [
+    {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"},
+    {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"},
+]
+
 [[package]]
 name = "super-collections"
 version = "0.6.2"
@@ -2362,4 +2408,4 @@ test = ["coverage", "hypothesis", "pytest"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.15"
-content-hash = "170dc2e3c4ba7d06456e66881cbdd2520cc015960cfc4f6224063913b3093050"
+content-hash = "2f28ec257d147660458dc4b655c06cfc92fc9cb6f7437f66ae061e7b8cac69d0"
diff --git a/pyntc/devices/eos_device.py b/pyntc/devices/eos_device.py
index 51a41bdc..88b26fe3 100644
--- a/pyntc/devices/eos_device.py
+++ b/pyntc/devices/eos_device.py
@@ -3,6 +3,7 @@
 import os
 import re
 import time
+from urllib.parse import urlparse
 
 from netmiko import ConnectHandler, FileTransfer
 from pyeapi import connect as eos_connect
@@ -23,6 +24,7 @@
     RebootTimeoutError,
 )
 from pyntc.utils import convert_list_by_key
+from pyntc.utils.models import FileCopyModel
 
 BASIC_FACTS_KM = {"model": "modelName", "os_version": "internalVersion", "serial_number": "serialNumber"}
 INTERFACES_KM = {
@@ -421,6 +423,267 @@ def file_copy_remote_exists(self, src, dest=None, file_system=None):
         log.debug("Host %s: File %s does not already exist on remote.", self.host, src)
         return False
 
+    def check_file_exists(self, filename, file_system=None):
+        """Check if a remote file exists by filename.
+
+        Args:
+            filename (str): The name of the file to check for on the remote device.
+            file_system (str): Supported only for Arista. The file system for the
+                remote file. If no file_system is provided, then the `get_file_system`
+                method is used to determine the correct file system to use.
+
+        Returns:
+            (bool): True if the remote file exists, False if it doesn't.
+
+        Raises:
+            CommandError: If there is an error in executing the command to check if the file exists.
+        """
+        exists = False
+
+        file_system = file_system or self._get_file_system()
+        command = f"dir {file_system}/{filename}"
+        result = self.native_ssh.send_command(command, read_timeout=30)
+
+        log.debug(
+            "Host %s: Checking if file %s exists on remote with command '%s' and result: %s",
+            self.host,
+            filename,
+            command,
+            result,
+        )
+
+        # Check for error patterns
+        if re.search(r"% Error listing directory|No such file|No files found|Path does not exist", result):
+            log.debug("Host %s: File %s does not exist on remote.", self.host, filename)
+            exists = False
+        elif re.search(rf"Directory of .*{filename}", result):
+            log.debug("Host %s: File %s exists on remote.", self.host, filename)
+            exists = True
+        else:
+            raise CommandError(command, f"Unable to determine if file {filename} exists on remote: {result}")
+
+        return exists
+
+    def get_remote_checksum(self, filename, hashing_algorithm="md5", **kwargs):
+        """Get the checksum of a remote file on Arista EOS device using netmiko SSH.
+
+        Uses Arista's 'verify' command via SSH to compute file checksums.
+        Note, Netmiko FileTransfer only supports `verify /md5`
+
+        Args:
+            filename (str): The name of the file to check for on the remote device.
+            hashing_algorithm (str): The hashing algorithm to use (default: "md5").
+            **kwargs: Additional keyword arguments.
+
+        Keyword Args:
+            file_system (str): The file system for the remote file (e.g., "flash:").
+
+        Returns:
+            (str): The checksum of the remote file.
+
+        Raises:
+            CommandError: If the verify command fails (but not if file doesn't exist).
+        """
+        file_system = kwargs.get("file_system")
+        if file_system is None:
+            file_system = self._get_file_system()
+
+        # Normalize file_system to Arista format (e.g., "flash:" or "/mnt/flash")
+        if file_system.endswith(":"):
+            # Already in shorthand format like "flash:"
+            pass
+        elif file_system.startswith("/"):
+            # Full path format like "/mnt/flash" - keep as is
+            pass
+        else:
+            # Assume shorthand without colon (e.g., "flash" -> "flash:")
+            file_system = f"{file_system}:"
+
+        # Build the path
+        if file_system.endswith(":"):
+            path = f"{file_system}{filename}"
+        else:
+            path = f"{file_system}/{filename}"
+
+        # Use Arista's verify command to get the checksum
+        # Example: verify /sha512 flash:nautobot.png
+        command = f"verify /{hashing_algorithm} {path}"
+
+        try:
+            result = self.native_ssh.send_command(command, read_timeout=30)
+
+            log.debug(
+                "Host %s: Verify command '%s' returned: %s",
+                self.host,
+                command,
+                result,
+            )
+
+            # Parse the checksum from the output
+            # Expected format: verify /sha512 (flash:nautobot.png) = <checksum>
+            match = re.search(r"=\s*([a-fA-F0-9]+)", result)
+            if match:
+                remote_checksum = match.group(1).lower()
+                log.debug("Host %s: Remote checksum for %s: %s", self.host, filename, remote_checksum)
+                return remote_checksum
+
+            log.error("Host %s: Could not parse checksum from verify output: %s", self.host, result)
+            raise CommandError(command, f"Could not parse checksum from verify output: {result}")
+
+        except Exception as e:
+            log.error("Host %s: Error getting remote checksum: %s", self.host, str(e))
+            raise CommandError(command, f"Error getting remote checksum: {str(e)}")
+
+    def remote_file_copy(self, src: FileCopyModel, dest=None, file_system=None, include_username=False, **kwargs):
+        """Copy a file from remote source to device.
+
+        Args:
+            src (FileCopyModel): The source file model with transfer parameters.
+            dest (str): Destination filename (defaults to src.file_name).
+            file_system (str): Device filesystem (auto-detected if not provided).
+            include_username (bool): Whether to include username in the copy command. Defaults to False.
+            **kwargs: Additional keyword arguments for future extensibility.
+
+        Raises:
+            TypeError: If src is not a FileCopyModel.
+            FileTransferError: If transfer or verification fails.
+            FileSystemNotFoundError: If filesystem cannot be determined.
+        """
+        # Validate input
+        if not isinstance(src, FileCopyModel):
+            raise TypeError("src must be an instance of FileCopyModel")
+
+        # Determine file system
+        if file_system is None:
+            file_system = self._get_file_system()
+
+        # Determine destination
+        if dest is None:
+            dest = src.file_name
+
+        log.debug("Host %s: Starting remote file copy for %s to %s/%s", self.host, src.file_name, file_system, dest)
+
+        # Open SSH connection and enable
+        self.open()
+        self.enable()
+
+        # Validate scheme
+        supported_schemes = ["http", "https", "scp", "ftp", "sftp", "tftp"]
+        if src.scheme not in supported_schemes:
+            raise ValueError(f"Unsupported scheme: {src.scheme}")
+
+        # Parse URL components
+        parsed = urlparse(src.download_url)
+        hostname = parsed.hostname
+        path = parsed.path
+        port = (
+            parsed.port
+            if parsed.port
+            else ("443" if src.scheme == "https" else "80" if src.scheme in ["http", "https"] else "")
+        )
+
+        # Build command based on scheme and credentials
+        detect_prompt = False
+
+        # TFTP, HTTP, HTTPS without credentials
+        if src.scheme in ["tftp", "http", "https"] and not include_username:
+            command = f"copy {src.download_url} {file_system}"
+            log.debug("Host %s: Preparing copy command without credentials: %s", self.host, src.scheme)
+
+        # HTTP/HTTPS with credentials embedded in URL
+        elif src.scheme in ["http", "https"] and (include_username and src.username):
+            port_str = f":{port}" if port else ""
+            command = f"copy {src.scheme}://{src.username}:{src.token}@{hostname}{port_str}{path} {file_system}"
+            log.debug("Host %s: Preparing copy command with embedded credentials for %s", self.host, src.scheme)
+
+        # SCP, FTP, SFTP with username (password via prompt)
+        elif src.scheme in ["scp", "ftp", "sftp"]:
+            port_str = f":{port}" if port else ""
+            command = f"copy {src.scheme}://{src.username}@{hostname}{port_str}{path} {file_system}"
+            detect_prompt = True
+            log.debug(
+                "Host %s: Preparing copy command with username for %s (password via prompt)", self.host, src.scheme
+            )
+
+        else:
+            raise ValueError(f"Unable to construct copy command for scheme {src.scheme} with provided credentials")
+
+        # Execute copy command
+        if detect_prompt and src.token:
+            # Use send_command_timing for interactive password prompt
+            output = self.native_ssh.send_command_timing(command, read_timeout=src.timeout, cmd_verify=False)
+            log.debug("Host %s: Copy command (with timing) output: %s", self.host, output)
+
+            if "Password:" in output or "password:" in output:
+                self.native_ssh.write_channel(src.token + "\n")
+                # Read the response after sending password
+                output += self.native_ssh.read_channel()
+                log.debug("Host %s: Output after password entry: %s", self.host, output)
+            elif any(error in output for error in ["Error", "Invalid", "Failed"]):
+                log.error("Host %s: Error detected in copy command output: %s", self.host, output)
+                raise FileTransferError(f"Error detected in copy command output: {output}")
+        else:
+            # Use regular send_command for non-interactive transfers
+            output = self.native_ssh.send_command(command, read_timeout=src.timeout)
+            log.debug("Host %s: Copy command output: %s", self.host, output)
+
+            if any(error in output for error in ["Error", "Invalid", "Failed"]):
+                log.error("Host %s: Error detected in copy command output: %s", self.host, output)
+                raise FileTransferError(f"Error detected in copy command output: {output}")
+
+        # Verify transfer success
+        verification_result = self.verify_file(
+            src.checksum, dest, hashing_algorithm=src.hashing_algorithm, file_system=file_system
+        )
+        log.debug(
+            "Host %s: File verification result for %s - Checksum: %s, Algorithm: %s, Result: %s",
+            self.host,
+            dest,
+            src.checksum,
+            src.hashing_algorithm,
+            verification_result,
+        )
+
+        if not verification_result:
+            log.error(
+                "Host %s: File verification failed for %s - Expected checksum: %s",
+                self.host,
+                dest,
+                src.checksum,
+            )
+            raise FileTransferError
+
+        log.info("Host %s: File %s transferred and verified successfully", self.host, dest)
+
+    def verify_file(self, checksum, filename, hashing_algorithm="md5", **kwargs):
+        """Verify a file on the remote device by confirming the file exists and validate the checksum.
+
+        Args:
+            checksum (str): The checksum of the file.
+            filename (str): The name of the file to check for on the remote device.
+            hashing_algorithm (str): The hashing algorithm to use (default: "md5").
+            **kwargs: Additional keyword arguments (e.g., file_system).
+
+        Returns:
+            (bool): True if the file is verified successfully, False otherwise.
+        """
+        exists = self.check_file_exists(filename, **kwargs)
+        device_checksum = (
+            self.get_remote_checksum(filename, hashing_algorithm=hashing_algorithm, **kwargs) if exists else None
+        )
+        if checksum == device_checksum:
+            log.debug("Host %s: Checksum verification successful for file %s", self.host, filename)
+            return True
+        else:
+            log.debug(
+                "Host %s: Checksum verification failed for file %s - Expected: %s, Actual: %s",
+                self.host,
+                filename,
+                checksum,
+                device_checksum,
+            )
+            return False
+
     def install_os(self, image_name, **vendor_specifics):
         """Install new OS on device.
 
diff --git a/pyntc/log.py b/pyntc/log.py
index 15e31f53..79b2f423 100644
--- a/pyntc/log.py
+++ b/pyntc/log.py
@@ -54,7 +54,7 @@ def init(**kwargs):
 
     logging.basicConfig(**kwargs)
     # info is defined at the end of the file
-    info("Logging initialized for host %s.", kwargs.get("host"))
+    info("Logging initialized for host %s.", kwargs.pop("host", None))
 
 
 def logger(level):
diff --git a/pyproject.toml b/pyproject.toml
index 697b00a9..9451d4bb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -51,6 +51,7 @@ attrs = "^23.2.0"
 towncrier = ">=23.6.0,<=24.8.0"
 ruff = "*"
 Markdown = "*"
+hypothesis = "*"
 
 [tool.poetry.group.docs.dependencies]
 # Rendering docs to HTML
diff --git a/tests/unit/test_devices/test_eos_device.py b/tests/unit/test_devices/test_eos_device.py
index 2d6bcdc2..5d3be07f 100644
--- a/tests/unit/test_devices/test_eos_device.py
+++ b/tests/unit/test_devices/test_eos_device.py
@@ -278,6 +278,8 @@ def test_file_copy_fail(self, mock_open, mock_close, mock_ssh, mock_ft):
         with self.assertRaises(FileTransferError):
             self.device.file_copy("source_file")
 
+    # TODO: unit test for remote_file_copy
+
     def test_reboot(self):
         self.device.reboot()
         self.device.native.enable.assert_called_with(["reload now"], encoding="json")
@@ -433,3 +435,1003 @@ def test_init_pass_port_and_timeout(mock_eos_connect):
     mock_eos_connect.assert_called_with(
         host="host", username="username", password="password", transport="http", port=8080, timeout=30
     )
+
+
+# Property-based tests for file system normalization
+try:
+    from hypothesis import given
+    from hypothesis import strategies as st
+except ImportError:
+    # Create dummy decorators if hypothesis is not available
+    def given(*args, **kwargs):
+        def decorator(func):
+            return func
+
+        return decorator
+
+    class _ST:
+        @staticmethod
+        def just(value):
+            return value
+
+        @staticmethod
+        def one_of(*args):
+            return args[0]
+
+    st = _ST()
+
+
+# Property-based tests for copy command construction
+from pyntc.utils.models import FileCopyModel
+
+# Property tests for Task 6: Input Validation in remote_file_copy()
+
+
+@given(
+    src=st.just("not_a_filecopymodel"),
+)
+def test_property_type_validation(src):
+    """Feature: arista-remote-file-copy, Property 1: Type Validation.
+
+    For any non-FileCopyModel object passed as `src`, the `remote_file_copy()`
+    method should raise a `TypeError`.
+
+    Validates: Requirements 1.2, 15.1
+    """
+    device = EOSDevice("host", "user", "pass")
+
+    with pytest.raises(TypeError) as exc_info:
+        device.remote_file_copy(src)
+
+    assert "src must be an instance of FileCopyModel" in str(exc_info.value)
+
+
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_file_system_auto_detection(mock_get_fs):
+    """Feature: arista-remote-file-copy, Property 26: File System Auto-Detection.
+
+    For any `remote_file_copy()` call without an explicit `file_system` parameter,
+    the method should call `_get_file_system()` to determine the default file system.
+
+    Validates: Requirements 11.1
+    """
+    mock_get_fs.return_value = "/mnt/flash"
+    device = EOSDevice("host", "user", "pass")
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123",
+        file_name="file.bin",
+    )
+
+    # Call remote_file_copy without file_system parameter
+    try:
+        device.remote_file_copy(src)
+    except Exception:
+        # We expect it to fail later, but we just want to verify _get_file_system was called
+        pass
+
+    # Verify _get_file_system was called
+    mock_get_fs.assert_called()
+
+
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_explicit_file_system_usage(mock_get_fs):
+    """Feature: arista-remote-file-copy, Property 27: Explicit File System Usage.
+
+    For any `remote_file_copy()` call with an explicit `file_system` parameter,
+    that value should be used instead of auto-detection.
+
+    Validates: Requirements 11.2
+    """
+    device = EOSDevice("host", "user", "pass")
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123",
+        file_name="file.bin",
+    )
+
+    # Call remote_file_copy with explicit file_system parameter
+    try:
+        device.remote_file_copy(src, file_system="/mnt/flash")
+    except Exception:
+        # We expect it to fail later, but we just want to verify _get_file_system was NOT called
+        pass
+
+    # Verify _get_file_system was NOT called
+    mock_get_fs.assert_not_called()
+
+
+@mock.patch.object(EOSDevice, "verify_file")
+@mock.patch.object(EOSDevice, "enable")
+@mock.patch.object(EOSDevice, "open")
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_default_destination_from_filecopymodel(mock_get_fs, mock_open, mock_enable, mock_verify):
+    """Feature: arista-remote-file-copy, Property 28: Default Destination from FileCopyModel.
+
+    For any `remote_file_copy()` call without an explicit `dest` parameter,
+    the destination should default to `src.file_name`.
+
+    Validates: Requirements 12.1
+    """
+    mock_get_fs.return_value = "/mnt/flash"
+    mock_verify.return_value = True
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/myfile.bin",
+        checksum="abc123",
+        file_name="myfile.bin",
+    )
+
+    # Call remote_file_copy without explicit dest
+    device.remote_file_copy(src)
+
+    # Verify verify_file was called with the default destination
+    mock_verify.assert_called()
+    call_args = mock_verify.call_args
+    assert call_args[0][1] == "myfile.bin"  # dest should be file_name
+
+
+@mock.patch.object(EOSDevice, "verify_file")
+@mock.patch.object(EOSDevice, "enable")
+@mock.patch.object(EOSDevice, "open")
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_explicit_destination_usage(mock_get_fs, mock_open, mock_enable, mock_verify):
+    """Feature: arista-remote-file-copy, Property 29: Explicit Destination Usage.
+
+    For any `remote_file_copy()` call with an explicit `dest` parameter,
+    that value should be used as the destination filename.
+
+    Validates: Requirements 12.2
+    """
+    mock_get_fs.return_value = "/mnt/flash"
+    mock_verify.return_value = True
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/myfile.bin",
+        checksum="abc123",
+        file_name="myfile.bin",
+    )
+
+    # Call remote_file_copy with explicit dest
+    device.remote_file_copy(src, dest="different_name.bin")
+
+    # Verify verify_file was called with the explicit destination
+    mock_verify.assert_called()
+    call_args = mock_verify.call_args
+    assert call_args[0][1] == "different_name.bin"  # dest should be the explicit value
+
+
+class TestRemoteFileCopy(unittest.TestCase):
+    """Tests for remote_file_copy method."""
+
+    @mock.patch("pyeapi.client.Node", autospec=True)
+    def setUp(self, mock_node):
+        self.device = EOSDevice("host", "user", "pass")
+        self.maxDiff = None
+        mock_node.enable.side_effect = enable
+        mock_node.config.side_effect = config
+        self.device.native = mock_node
+
+    def tearDown(self):
+        self.device.native.reset_mock()
+
+    def test_remote_file_copy_invalid_src_type(self):
+        """Test remote_file_copy raises TypeError for invalid src type."""
+        with pytest.raises(TypeError) as exc_info:
+            self.device.remote_file_copy("not_a_model")
+        assert "src must be an instance of FileCopyModel" in str(exc_info.value)
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_skip_transfer_on_checksum_match(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy skips transfer when file exists with matching checksum."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = True
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        # Should return without raising exception
+        self.device.remote_file_copy(src)
+
+        # Verify that verify_file was called
+        mock_verify.assert_called()
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_http_transfer(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy executes HTTP transfer correctly."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = True  # Verification passes
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        # Should not raise exception
+        self.device.remote_file_copy(src)
+
+        # Verify open and enable were called
+        mock_open.assert_called_once()
+        mock_enable.assert_called_once()
+
+        # Verify send_command was called with correct command
+        mock_ssh.send_command.assert_called()
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_verification_failure(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy raises FileTransferError when verification fails."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = False  # Verification fails
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        # Should raise FileTransferError
+        with pytest.raises(FileTransferError):
+            self.device.remote_file_copy(src)
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_with_explicit_dest(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy uses explicit dest parameter."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = True
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        # Call with explicit dest
+        self.device.remote_file_copy(src, dest="custom_name.bin")
+
+        # Verify verify_file was called with custom dest
+        call_args = mock_verify.call_args
+        assert call_args[0][1] == "custom_name.bin"
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_with_explicit_file_system(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy uses explicit file_system parameter."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_verify.return_value = True
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        # Call with explicit file_system
+        self.device.remote_file_copy(src, file_system="flash:")
+
+        # Verify _get_file_system was NOT called
+        mock_get_fs.assert_not_called()
+
+        # Verify send_command was called with correct file_system
+        call_args = mock_ssh.send_command.call_args
+        assert "flash:" in call_args[0][0]
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_scp_with_credentials(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy constructs SCP command with username only."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = True
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command_timing.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="scp://user:pass@server.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+        )
+
+        self.device.remote_file_copy(src)
+
+        # Verify send_command_timing was called with SCP command containing username only
+        # Token is provided at the Arista "Password:" prompt
+        call_args = mock_ssh.send_command_timing.call_args
+        command = call_args[0][0]
+        assert "scp://" in command
+        assert "user@" in command
+        assert "pass@" not in command  # Password should not be in command
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_remote_file_copy_timeout_applied(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test remote_file_copy applies timeout to send_command."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "flash:"
+        mock_verify.return_value = True
+
+        # Mock netmiko connection
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        self.device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://example.com/file.bin",
+            checksum="abc123",
+            file_name="file.bin",
+            timeout=1800,
+        )
+
+        self.device.remote_file_copy(src)
+
+        # Verify send_command was called with correct timeout
+        call_args = mock_ssh.send_command.call_args
+        assert call_args[1]["read_timeout"] == 1800
+
+
+# Property-based tests for Task 7: Pre-transfer verification
+
+
+@mock.patch.object(EOSDevice, "verify_file")
+@mock.patch.object(EOSDevice, "enable")
+@mock.patch.object(EOSDevice, "open")
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_skip_transfer_on_checksum_match(mock_get_fs, mock_open, mock_enable, mock_verify):
+    """Feature: arista-remote-file-copy, Property 14: Skip Transfer on Checksum Match.
+
+    For any file that already exists on the device with a matching checksum,
+    the `remote_file_copy()` method should return successfully after verification.
+
+    Validates: Requirements 5.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    mock_get_fs.return_value = "/mnt/flash"
+    mock_verify.return_value = True  # File exists with matching checksum
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123def456",
+        file_name="file.bin",
+    )
+
+    # Call remote_file_copy
+    device.remote_file_copy(src)
+
+    # Verify that verify_file was called
+    mock_verify.assert_called()
+
+    # Verify that send_command was called (transfer always occurs)
+    device.native_ssh.send_command.assert_called()
+
+
+@mock.patch.object(EOSDevice, "verify_file")
+@mock.patch.object(EOSDevice, "enable")
+@mock.patch.object(EOSDevice, "open")
+@mock.patch.object(EOSDevice, "_get_file_system")
+def test_property_proceed_on_checksum_mismatch(mock_get_fs, mock_open, mock_enable, mock_verify):
+    """Feature: arista-remote-file-copy, Property 15: Proceed on Checksum Mismatch.
+
+    For any file that exists on the device but has a mismatched checksum,
+    the `remote_file_copy()` method should proceed with the file transfer.
+
+    Validates: Requirements 5.3
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    mock_get_fs.return_value = "/mnt/flash"
+    # Verification fails (file doesn't exist or checksum mismatches)
+    mock_verify.return_value = False
+
+    device = EOSDevice("host", "user", "pass")
+    mock_ssh = mock.MagicMock()
+    mock_ssh.send_command.return_value = "Copy completed successfully"
+    device.native_ssh = mock_ssh
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123def456",
+        file_name="file.bin",
+    )
+
+    # Call remote_file_copy - should raise FileTransferError because verification fails
+    with pytest.raises(FileTransferError):
+        device.remote_file_copy(src)
+
+    # Verify that send_command was called with a copy command
+    mock_ssh.send_command.assert_called()
+    call_args = mock_ssh.send_command.call_args
+    assert "copy" in call_args[0][0].lower()
+
+
+# Tests for Task 8: Command Execution
+
+
+class TestRemoteFileCopyCommandExecution(unittest.TestCase):
+    """Tests for command execution flow in remote_file_copy."""
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_command_execution_with_http(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test command execution for HTTP transfer."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "/mnt/flash"
+        mock_verify.return_value = True
+
+        device = EOSDevice("host", "user", "pass")
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://server.example.com/file.bin",
+            checksum="abc123def456",
+            file_name="file.bin",
+        )
+
+        device.remote_file_copy(src)
+
+        # Verify open() was called
+        mock_open.assert_called_once()
+
+        # Verify enable() was called
+        mock_enable.assert_called_once()
+
+        # Verify send_command was called with HTTP copy command
+        mock_ssh.send_command.assert_called()
+        call_args = mock_ssh.send_command.call_args
+        assert "copy http://" in call_args[0][0]
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_command_execution_with_scp_credentials(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test command execution for SCP transfer with username only."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "/mnt/flash"
+        mock_verify.return_value = True
+
+        device = EOSDevice("host", "user", "pass")
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command_timing.return_value = "Copy completed successfully"
+        device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="scp://admin:password@backup.example.com/configs/startup-config",
+            checksum="abc123def456",
+            file_name="startup-config",
+            username="admin",
+            token="password",
+        )
+
+        device.remote_file_copy(src)
+
+        # Verify send_command_timing was called with SCP copy command including username only
+        # Token is provided at the Arista "Password:" prompt
+        mock_ssh.send_command_timing.assert_called()
+        call_args = mock_ssh.send_command_timing.call_args
+        assert "copy scp://" in call_args[0][0]
+        assert "admin@" in call_args[0][0]
+        assert "password@" not in call_args[0][0]  # Password should not be in command
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_timeout_applied_to_send_command(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test that timeout is applied to send_command calls."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "/mnt/flash"
+        mock_verify.return_value = True
+
+        device = EOSDevice("host", "user", "pass")
+        mock_ssh = mock.MagicMock()
+        mock_ssh.send_command.return_value = "Copy completed successfully"
+        device.native_ssh = mock_ssh
+
+        src = FileCopyModel(
+            download_url="http://server.example.com/file.bin",
+            checksum="abc123def456",
+            file_name="file.bin",
+            timeout=600,
+        )
+
+        device.remote_file_copy(src)
+
+        # Verify send_command was called with the specified timeout
+        mock_ssh.send_command.assert_called()
+        call_args = mock_ssh.send_command.call_args
+        assert call_args[1]["read_timeout"] == 600
+
+
+# Tests for Task 9: Post-transfer Verification
+
+
+@pytest.mark.parametrize(
+    "checksum,algorithm",
+    [
+        ("abc123def456", "md5"),
+        ("abc123def456789", "sha256"),
+    ],
+)
+def test_property_post_transfer_verification(checksum, algorithm):
+    """Feature: arista-remote-file-copy, Property 20: Post-Transfer Verification.
+
+    For any completed file transfer, the method should verify the file exists
+    on the device and compute its checksum using the specified algorithm.
+
+    Validates: Requirements 9.1, 9.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+
+    with mock.patch.object(device, "verify_file") as mock_verify:
+        with mock.patch.object(device, "_get_file_system") as mock_get_fs:
+            with mock.patch.object(device, "open"):
+                with mock.patch.object(device, "enable"):
+                    mock_get_fs.return_value = "/mnt/flash"
+                    mock_verify.return_value = True
+                    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+                    src = FileCopyModel(
+                        download_url="http://server.example.com/file.bin",
+                        checksum=checksum,
+                        file_name="file.bin",
+                        hashing_algorithm=algorithm,
+                    )
+
+                    device.remote_file_copy(src)
+
+                    # Verify that verify_file was called
+                    mock_verify.assert_called()
+
+
+@pytest.mark.parametrize(
+    "checksum,algorithm",
+    [
+        ("abc123def456", "md5"),
+        ("abc123def456789", "sha256"),
+    ],
+)
+def test_property_checksum_match_verification(checksum, algorithm):
+    """Feature: arista-remote-file-copy, Property 21: Checksum Match Verification.
+
+    For any transferred file where the computed checksum matches the expected checksum,
+    the method should consider the transfer successful.
+
+    Validates: Requirements 9.3
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+
+    with mock.patch.object(device, "verify_file") as mock_verify:
+        with mock.patch.object(device, "_get_file_system") as mock_get_fs:
+            with mock.patch.object(device, "open"):
+                with mock.patch.object(device, "enable"):
+                    mock_get_fs.return_value = "/mnt/flash"
+                    # Verification passes
+                    mock_verify.return_value = True
+                    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+                    src = FileCopyModel(
+                        download_url="http://server.example.com/file.bin",
+                        checksum=checksum,
+                        file_name="file.bin",
+                        hashing_algorithm=algorithm,
+                    )
+
+                    # Should not raise an exception
+                    device.remote_file_copy(src)
+
+
+def test_property_checksum_mismatch_error():
+    """Feature: arista-remote-file-copy, Property 22: Checksum Mismatch Error.
+
+    For any transferred file where the computed checksum does not match the expected checksum,
+    the method should raise a FileTransferError.
+
+    Validates: Requirements 9.4
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+
+    with mock.patch.object(device, "verify_file") as mock_verify:
+        with mock.patch.object(device, "_get_file_system") as mock_get_fs:
+            with mock.patch.object(device, "open"):
+                with mock.patch.object(device, "enable"):
+                    mock_get_fs.return_value = "/mnt/flash"
+                    # First call: file doesn't exist (False)
+                    # Second call: checksum mismatch (False)
+                    mock_verify.side_effect = [False, False]
+                    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+                    src = FileCopyModel(
+                        download_url="http://server.example.com/file.bin",
+                        checksum="abc123def456",
+                        file_name="file.bin",
+                    )
+
+                    # Should raise FileTransferError
+                    with pytest.raises(FileTransferError):
+                        device.remote_file_copy(src)
+
+
+def test_property_missing_file_after_transfer_error():
+    """Feature: arista-remote-file-copy, Property 23: Missing File After Transfer Error.
+
+    For any transfer that completes but the file does not exist on the device afterward,
+    the method should raise a FileTransferError.
+
+    Validates: Requirements 9.5
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+
+    with mock.patch.object(device, "verify_file") as mock_verify:
+        with mock.patch.object(device, "_get_file_system") as mock_get_fs:
+            with mock.patch.object(device, "open"):
+                with mock.patch.object(device, "enable"):
+                    mock_get_fs.return_value = "/mnt/flash"
+                    # First call: file doesn't exist (False)
+                    # Second call: file still doesn't exist (False)
+                    mock_verify.side_effect = [False, False]
+                    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+                    src = FileCopyModel(
+                        download_url="http://server.example.com/file.bin",
+                        checksum="abc123def456",
+                        file_name="file.bin",
+                    )
+
+                    # Should raise FileTransferError
+                    with pytest.raises(FileTransferError):
+                        device.remote_file_copy(src)
+
+
+# Tests for Task 10: Timeout and FTP Support
+
+
+@pytest.mark.parametrize("timeout", [300, 600, 900, 1800])
+def test_property_timeout_application(timeout):
+    """Feature: arista-remote-file-copy, Property 24: Timeout Application.
+
+    For any FileCopyModel with a specified timeout value, that timeout should be used
+    when sending commands to the device during transfer.
+
+    Validates: Requirements 10.1, 10.3
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    device = EOSDevice("host", "user", "pass")
+    device.native_ssh = mock.MagicMock()
+
+    with mock.patch.object(device, "verify_file") as mock_verify:
+        with mock.patch.object(device, "_get_file_system") as mock_get_fs:
+            with mock.patch.object(device, "open"):
+                with mock.patch.object(device, "enable"):
+                    mock_get_fs.return_value = "/mnt/flash"
+                    mock_verify.return_value = True
+                    device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+                    src = FileCopyModel(
+                        download_url="http://server.example.com/file.bin",
+                        checksum="abc123def456",
+                        file_name="file.bin",
+                        timeout=timeout,
+                    )
+
+                    device.remote_file_copy(src)
+
+                    # Verify send_command was called with the correct timeout
+                    call_args = device.native_ssh.send_command.call_args
+                    assert call_args[1]["read_timeout"] == timeout
+
+
+def test_property_default_timeout_value():
+    """Feature: arista-remote-file-copy, Property 25: Default Timeout Value.
+
+    For any FileCopyModel without an explicit timeout, the default timeout should be 900 seconds.
+
+    Validates: Requirements 10.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123def456",
+        file_name="file.bin",
+    )
+
+    # Verify default timeout is 900
+    assert src.timeout == 900
+
+
+@pytest.mark.parametrize("ftp_passive", [True, False])
+def test_property_ftp_passive_mode_configuration(ftp_passive):
+    """Feature: arista-remote-file-copy, Property 30/31: FTP Passive Mode Configuration.
+
+    For any FileCopyModel with ftp_passive flag, the FTP transfer should use the specified mode.
+
+    Validates: Requirements 19.1, 19.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    src = FileCopyModel(
+        download_url="ftp://admin:password@ftp.example.com/images/eos.swi",
+        checksum="abc123def456",
+        file_name="eos.swi",
+        ftp_passive=ftp_passive,
+    )
+
+    # Verify ftp_passive is set correctly
+    assert src.ftp_passive == ftp_passive
+
+
+def test_property_default_ftp_passive_mode():
+    """Feature: arista-remote-file-copy, Property 32: Default FTP Passive Mode.
+
+    For any FileCopyModel without an explicit ftp_passive parameter, the default should be True.
+
+    Validates: Requirements 19.3
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    src = FileCopyModel(
+        download_url="ftp://admin:password@ftp.example.com/images/eos.swi",
+        checksum="abc123def456",
+        file_name="eos.swi",
+    )
+
+    # Verify default ftp_passive is True
+    assert src.ftp_passive is True
+
+
+# Tests for Task 11: Error Handling and Logging
+
+
+class TestRemoteFileCopyErrorHandling(unittest.TestCase):
+    """Tests for error handling in remote_file_copy."""
+
+    def test_invalid_src_type_raises_typeerror(self):
+        """Test that invalid src type raises TypeError."""
+        device = EOSDevice("host", "user", "pass")
+
+        with pytest.raises(TypeError) as exc_info:
+            device.remote_file_copy("not a FileCopyModel")
+
+        assert "src must be an instance of FileCopyModel" in str(exc_info.value)
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_transfer_failure_raises_filetransfererror(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test that transfer failure raises FileTransferError."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "/mnt/flash"
+        mock_verify.side_effect = [False, False]  # Post-transfer verification fails
+
+        device = EOSDevice("host", "user", "pass")
+        device.native_ssh = mock.MagicMock()
+        device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+        src = FileCopyModel(
+            download_url="http://server.example.com/file.bin",
+            checksum="abc123def456",
+            file_name="file.bin",
+        )
+
+        with pytest.raises(FileTransferError):
+            device.remote_file_copy(src)
+
+    @mock.patch.object(EOSDevice, "verify_file")
+    @mock.patch.object(EOSDevice, "enable")
+    @mock.patch.object(EOSDevice, "open")
+    @mock.patch.object(EOSDevice, "_get_file_system")
+    def test_logging_on_transfer_success(self, mock_get_fs, mock_open, mock_enable, mock_verify):
+        """Test that transfer success is logged."""
+        from pyntc.utils.models import FileCopyModel
+
+        mock_get_fs.return_value = "/mnt/flash"
+        mock_verify.return_value = True
+
+        device = EOSDevice("host", "user", "pass")
+        device.native_ssh = mock.MagicMock()
+        device.native_ssh.send_command.return_value = "Copy completed successfully"
+
+        src = FileCopyModel(
+            download_url="http://server.example.com/file.bin",
+            checksum="abc123def456",
+            file_name="file.bin",
+        )
+
+        with mock.patch("pyntc.devices.eos_device.log") as mock_log:
+            device.remote_file_copy(src)
+
+            # Verify that info log was called for successful transfer
+            assert any("transferred and verified successfully" in str(call) for call in mock_log.info.call_args_list)
+
+
+# Tests for Task 12: FileCopyModel Validation
+
+
+@pytest.mark.parametrize("algorithm", ["md5", "sha256", "sha512"])
+def test_property_hashing_algorithm_validation(algorithm):
+    """Feature: arista-remote-file-copy, Property 10: Hashing Algorithm Validation.
+
+    For any unsupported hashing algorithm, FileCopyModel initialization should raise a ValueError.
+
+    Validates: Requirements 6.3, 17.1, 17.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    # Should not raise for supported algorithms
+    src = FileCopyModel(
+        download_url="http://server.example.com/file.bin",
+        checksum="abc123def456",
+        file_name="file.bin",
+        hashing_algorithm=algorithm,
+    )
+
+    assert src.hashing_algorithm == algorithm
+
+
+def test_property_case_insensitive_algorithm_validation():
+    """Feature: arista-remote-file-copy, Property 11: Case-Insensitive Algorithm Validation.
+
+    For any hashing algorithm specified in different cases, the FileCopyModel should accept it as valid.
+
+    Validates: Requirements 17.3
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    # Should accept case-insensitive algorithms
+    for algorithm in ["MD5", "md5", "Md5", "SHA256", "sha256", "Sha256"]:
+        src = FileCopyModel(
+            download_url="http://server.example.com/file.bin",
+            checksum="abc123def456",
+            file_name="file.bin",
+            hashing_algorithm=algorithm,
+        )
+
+        # Verify it was accepted (no exception raised)
+        assert src.hashing_algorithm.lower() in ["md5", "sha256"]
+
+
+@pytest.mark.parametrize(
+    "url,expected_username,expected_token",
+    [
+        ("scp://admin:password@server.com/path", "admin", "password"),
+        ("ftp://user:pass123@ftp.example.com/file", "user", "pass123"),
+    ],
+)
+def test_property_url_credential_extraction(url, expected_username, expected_token):
+    """Feature: arista-remote-file-copy, Property 12: URL Credential Extraction.
+
+    For any URL containing embedded credentials, FileCopyModel should extract username and password.
+
+    Validates: Requirements 3.1, 16.1, 16.2, 16.3, 16.4, 16.5, 16.6
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    src = FileCopyModel(
+        download_url=url,
+        checksum="abc123def456",
+        file_name="file.bin",
+    )
+
+    # Verify credentials were extracted
+    assert src.username == expected_username
+    assert src.token == expected_token
+
+
+def test_property_explicit_credentials_override():
+    """Feature: arista-remote-file-copy, Property 13: Explicit Credentials Override.
+
+    For any FileCopyModel where both URL-embedded credentials and explicit fields are provided,
+    the explicit fields should take precedence.
+
+    Validates: Requirements 3.2
+    """
+    from pyntc.utils.models import FileCopyModel
+
+    src = FileCopyModel(
+        download_url="scp://url_user:url_pass@server.com/path",
+        checksum="abc123def456",
+        file_name="file.bin",
+        username="explicit_user",
+        token="explicit_pass",
+    )
+
+    # Verify explicit credentials take precedence
+    assert src.username == "explicit_user"
+    assert src.token == "explicit_pass"