Merge lp:~canonical-platform-qa/ubuntu-system-tests/mtp_refactoring_merge_and_bugfix into lp:ubuntu-system-tests

[Sergio Cazzolato]

.MTP helper created including different objects to manage mtp tests and allowing any other test to use mtp feature.
.Merge with scope test. New filesystem paths are being used in the mtp tests.
.Fix clean_dir method of the filesystem helper. The old implementation was making the media scanner fail after the media dir is cleaned.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:154
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/517/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/245
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/246
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/245

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/517/rebuild

review: Approve (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/mtp_refactoring_merge_and_bugfix]

155. By Sergio Cazzolato on 2015-07-17

Fix test cases test_copy_large_number_of_files

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:155
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/519/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/247
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/248
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/247

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/519/rebuild

review: Approve (continuous-integration)

[Brendan Donegan (brendan-donegan)]

Code looks fine and everything seems to still work

review: Approve

[Richard Huddie (rhuddie)]

Looks good, I ran a test and it worked fine.

review: Approve

=== modified file 'ubuntu_system_tests/helpers/file_system.py'
--- ubuntu_system_tests/helpers/file_system.py	2015-07-15 11:06:17 +0000
+++ ubuntu_system_tests/helpers/file_system.py	2015-07-17 19:25:19 +0000
@@ -51,6 +51,8 @@
 DIR_TEST_DATA_TEXT = os.path.join(DIR_TEST_DATA, 'text')
 DIR_TEST_DATA_VIDEO = os.path.join(DIR_TEST_DATA, 'video')
 
+DIR_TEMP = '/tmp'
+
 
 def delete_file(file_name):
     """Delete the file passed as parameter. In case the file does not
@@ -78,13 +80,18 @@
 
 def remove_dir(dir_path):
     """Remove the directory"""
-    shutil.rmtree(dir_path, True)
+    if os.path.isdir(dir_path):
+        shutil.rmtree(dir_path, True)
 
 
 def clean_dir(dir_path):
     """Delete all the content of the directory"""
-    remove_dir(dir_path)
-    os.makedirs(dir_path)
+    for obj in os.listdir(dir_path):
+        obj_path = os.path.join(dir_path, obj)
+        if os.path.isfile(obj_path):
+            os.remove(obj_path)
+        else:
+            remove_dir(obj_path)
 
 
 def calculate_file_sha1(file_path):
 
=== added file 'ubuntu_system_tests/helpers/mtp.py'
--- ubuntu_system_tests/helpers/mtp.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/mtp.py	2015-07-17 19:25:19 +0000
@@ -0,0 +1,302 @@
+
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+import os
+import shutil
+
+from ubuntu_system_tests.helpers import file_system as fs
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_XDG_RUNTIME_DIR = '/run/user/1000'
+
+
+class MTPObjBase:
+    """ Base class used to represent objects that are copied through mtp"""
+
+    def __init__(self, remote_helper):
+        self.remote_helper = remote_helper
+        self.local_src_path = ""
+        self.local_dst_path = ""
+        self.remote_src_path = ""
+        self.remote_dst_path = ""
+
+    def validate_remote_copy(self):
+        """  Validate the src and dst paths are defined """
+        if not self.remote_src_path or not self.remote_dst_path:
+            raise RuntimeError("Remote copy cannot be done, remote_src_path "
+                               "and remote_mtp_path have to be defined")
+
+    def validate_send_to_host(self):
+        """  Validate the src and dst paths are defined """
+        if not self.local_src_path or not self.remote_src_path:
+            raise RuntimeError("Send to host cannot be done, local_src_path "
+                               "and remote_src_path have to be defined")
+
+
+class MTPFile(MTPObjBase):
+    """ This class represents a file which is copied through mtp"""
+
+    def __init__(self, remote_helper):
+        super(MTPFile, self).__init__(remote_helper)
+        self.sha1 = ""
+
+    @property
+    def name(self):
+        """  Retrieve the name based of the paths defined """
+        return os.path.basename(self.local_src_path) or \
+            os.path.basename(self.remote_src_path) or \
+            os.path.basename(self.remote_dst_path) or \
+            os.path.basename(self.local_dst_path)
+
+    def clean(self):
+        """ Clean the file in the different places where the file has been
+        copied. This method is used mainly for the clean up of the file  """
+        fs.delete_file(self.local_src_path)
+        if self.remote_src_path:
+            self.remote_helper.remove_file(self.remote_src_path)
+        if self.remote_dst_path:
+            self.remote_helper.remove_file(self.remote_dst_path)
+        fs.delete_file(self.local_dst_path)
+
+    def remote_copy(self, remote_dst_path=None):
+        """ Copy the file in the remote host from src to dst
+        :param remote_dst_path: the remote destination in case it has not been
+        defined previously
+        """
+        if remote_dst_path:
+            self.remote_dst_path = remote_dst_path
+        self.validate_remote_copy()
+        logger.info("Copying remote file from {src_path} to {mtp_path}".
+                    format(src_path=self.remote_src_path,
+                           mtp_path=self.remote_dst_path))
+        self.remote_helper.copy_file(self.remote_src_path,
+                                     self.remote_dst_path)
+
+    def get_remote_dst_sha1(self):
+        """ Get the sha1 digest calculated in the remote host for the file
+        located in the remote_dst_path
+        """
+        if not self.remote_dst_path:
+            raise RuntimeError("Attribute remote_dst_path has to de defined")
+        return self.remote_helper.get_sha1(self.remote_dst_path)
+
+    def send_to_host(self, path=None):
+        """ Send the file from the device to the ubuntu host. The
+        remote_src_path will be updated in case the path is defined
+        :param path: The path in the remote host where the file is copied
+        """
+        if path:
+            self.remote_src_path = os.path.join(path, self.name)
+        self.validate_send_to_host()
+        logger.info("Sending file to remote host from {local_path} to "
+                    "{remote_path}".format(local_path=self.local_src_path,
+                                           remote_path=self.remote_src_path))
+        self.remote_helper.put(self.local_src_path, self.remote_src_path)
+
+    def compare(self, file_path):
+        """ Compare the local file to the file located in the path
+        :return:True if the files are equal, false otherwise
+        """
+        return fs.compare_files(self.local_src_path, file_path)
+
+
+class MTPDir(MTPObjBase):
+    """ This class represents a directory which is copied through mtp"""
+
+    def __init__(self, remote_helper):
+        super(MTPDir, self).__init__(remote_helper)
+
+    @property
+    def name(self):
+        """  Retrieve the name based of the paths defined """
+        return os.path.basename(self.local_src_path) or \
+            os.path.basename(self.remote_src_path) or \
+            os.path.basename(self.remote_dst_path) or \
+            os.path.basename(self.local_dst_path)
+
+    def clean(self):
+        """ Clean the dir in the different places where the dir has been
+        copied. This method is used mainly for the clean up of the dir  """
+        fs.remove_dir(self.local_src_path)
+        if self.remote_src_path:
+            self.remote_helper.remove_dir(self.remote_src_path)
+        if self.remote_dst_path:
+            self.remote_helper.remove_dir(self.remote_dst_path)
+        fs.remove_dir(self.local_dst_path)
+
+    def remote_copy(self, remote_dst_path=None):
+        """ Copy the dir in the remote host from src to dst
+        :param remote_dst_path: the remote destination in case it has not been
+        defined previously
+        """
+        if remote_dst_path:
+            self.remote_dst_path = remote_dst_path
+        self.validate_remote_copy()
+        logger.info("Copying remote directory from {src_path} to {mtp_path}".
+                    format(src_path=self.remote_src_path,
+                           mtp_path=self.remote_dst_path))
+        self.remote_helper.copy_dir(self.remote_src_path,
+                                    self.remote_dst_path)
+
+
+class MTPObjFactory:
+    """ A factory class used to create the mtp entities in the local and
+    remote host """
+
+    def __init__(self, remote_helper, clean_up):
+        """
+        :param remote_helper: The helper to interact with the remote host
+        :param clean_up: The method used to clean up the objects created
+        """
+        self.remote_helper = remote_helper
+        self.clean_up = clean_up
+
+    def new_file(self):
+        """ Create an MTPFile object and add a clean up for it """
+        file = MTPFile(self.remote_helper)
+        self.clean_up(file.clean)
+        return file
+
+    def create_random_file(self, dir, ext='', sha1=True):
+        """ Create a MTPFile object with random name
+        :param dir: The dir where the file is created
+        :param ext: The extension of the file to be created
+        :param sha1: if True, the sha1 is calculated and stores in the file
+        :return: The created file with the local src path already set
+        """
+        file = self.new_file()
+        file.local_src_path = fs.create_random_file(dir, ext)
+        if sha1:
+            file.sha1 = fs.calculate_file_sha1(file.local_src_path)
+        return file
+
+    def create_file(self, src_file, temp=True):
+        """ Create a MTPFile object based on a real file
+        :param src_file: The real file used to create the MTPFile obj
+        :param temp: if True, the file is copied to a temp dir. The temp is
+        used to avoid the original file is deleted in the clean-up
+        :return: The created file object with the local src path already set
+        """
+        file = self.new_file()
+        file.local_src_path = src_file
+        if temp:
+            file.local_src_path = os.path.join(fs.DIR_TEMP, file.name)
+            shutil.copy(src_file, file.local_src_path)
+        return file
+
+    def create_remote_file(self, path=None, name=None, ext='', sha1=True,
+                           kb=0, mb=0, gb=0):
+        """ Create a file in the remote host
+        :param path: The path where the file is created, if None, the file will
+        be created in a temp dir
+        :param name: The name of the file to be created, if None, will be used
+        a random name
+        :param ext: the extension of the file
+        :param sha1: if True, the sha1 is calculated and stores in the file
+        :param kb: The kilobytes of the file to be created
+        :param mb: The megabytes of the file to be created
+        :param gb: The gigabytes of the file to be created
+        :return: The created file with random content and size equals to
+        kb kilobytes + mb megabytes + gb gigabytes
+        """
+        file = self.new_file()
+        file_path = path or fs.DIR_TEMP
+        file_name = name or fs.get_random_string()
+        file.remote_src_path = os.path.join(file_path, file_name + ext)
+        self.remote_helper.create_random_file(file.remote_src_path, kb=kb,
+                                              mb=mb, gb=gb)
+        if sha1:
+            file.sha1 = self.remote_helper.get_sha1(file.remote_src_path)
+        return file
+
+    def new_dir(self):
+        """ Create an MTPDir object and add a clean up for it """
+        dir = MTPDir(self.remote_helper)
+        self.clean_up(dir.clean)
+        return dir
+
+    def create_remote_dir(self, path=None, name=None):
+        """
+        Create a dir in the remote host
+        :param path: the name path where the new dir has to be created
+        :param name: the name of the dir, in case the name is not defined,
+        a random name is used
+        """
+        dir = self.new_dir()
+        dir_path = path or fs.DIR_TEMP
+        dir_name = name or fs.get_random_string()
+        dir.remote_src_path = os.path.join(dir_path, dir_name)
+        self.remote_helper.create_dir(dir.remote_src_path)
+        return dir
+
+
+class MTPHelper:
+
+    def __init__(self, remote_helper):
+        self.remote_helper = remote_helper
+        self.mtp_dir = self._calculate_mtp_dir()
+
+    def get_mtp_path(self, *paths):
+        """ Retrieve the mtp path following the desired paths
+        :param paths: A list of subdir to the destination path
+        :return: The mtp path already escaped to the destination path
+        """
+        return '"' + os.path.join(self.mtp_dir, *paths) + '"'
+
+    def _calculate_mtp_dir(self):
+        """ Get the path in the ubuntu host machine which maps to the mtp dir.
+        Use a random file to identify the device internal storage destination.
+        """
+        file = fs.create_random_file(fs.DIR_HOME_DOCUMENTS, ext='.tmp')
+        docs_mtp_dir = self._get_mtp_dir(fs.DIR_DOCUMENTS,
+                                         os.path.basename(file))
+        os.remove(file)
+        return os.path.dirname(docs_mtp_dir)
+
+    def _get_mtp_dir(self, dir_to_map, filename):
+        """ Determine the full_path in the ubuntu host machine which maps the
+        file and directory in the device
+        :param dir_to_map: The directory to map
+        :param filename: The name of the file to be mapped
+        :return: the full path that maps the dir_to_map and filename in the
+                 device
+        """
+        cmd_line = "python3 -c \"import glob; import os; " \
+                   "print(glob.glob(os.getenv('XDG_RUNTIME_DIR', " \
+                   "'{default}') + '/gvfs/*/*/{dir}/{filename}')[0])\"".\
+            format(default=DEFAULT_XDG_RUNTIME_DIR,
+                   dir=dir_to_map,
+                   filename=filename)
+
+        file_path = self.remote_helper.run(cmd_line).strip()
+        if file_path:
+            return os.path.dirname(file_path)
+        return None
+
+    def replicate_file(self, src_file, dst_dir, dst_files):
+        """ Copy the src file to the dst directory with the different names
+        stored in the dst_files variable
+        :param src_file: the source file to replicate
+        :param dst_dir: the destination directory to copy the files
+        :param dst_files: the target names to use
+        """
+        for file in dst_files:
+            src_file.remote_copy(os.path.join(dst_dir.remote_src_path, file))
 
=== modified file 'ubuntu_system_tests/helpers/ssh.py'
--- ubuntu_system_tests/helpers/ssh.py	2015-07-10 19:41:55 +0000
+++ ubuntu_system_tests/helpers/ssh.py	2015-07-17 19:25:19 +0000
@@ -21,6 +21,8 @@
 import os
 import paramiko
 
+from ubuntu_system_tests import config
+
 logger = logging.getLogger(__name__)
 
 
@@ -45,19 +47,26 @@
 
         return "".join(stdout.readlines())
 
-    def copy(self, localpath, remotepath):
-        """Copy a file through sftp from the localpath to the remotepath"""
-        if not os.path.isfile(localpath):
+    def put(self, local_path, remote_path):
+        """Copy a file through sftp from the local_path to the remote_path"""
+        if not os.path.isfile(local_path):
             raise RuntimeError("File to copy does not exist")
 
         sftp = self.client.open_sftp()
-        sftp.put(localpath, remotepath)
+        sftp.put(local_path, remote_path)
         sftp.close()
 
 
 class LinuxRemoteHelper(SSH):
     """This class executes remote linux commands through the ssh connection"""
 
+    def __init__(self):
+        config_stack = config.get_device_config_stack()
+        host = config_stack.get('ssh_ip')
+        user = config_stack.get('ssh_user')
+        password = config_stack.get('ssh_password')
+        super(LinuxRemoteHelper, self).__init__(host, user, password)
+
     def remove_dir(self, dir_name):
         self.run('rm -rf {}'.format(dir_name))
 
@@ -85,7 +94,7 @@
         :param mb: The megabytes of the file
         :param gb: The gigabytes fo the file
         :return: The file path to the created file with random content and size
-        equals to kb KiloBytes + mb MegaBytes + gb GigaBytes
+        equals to kb kilobytes + mb megabytes + gb gigabytes
         """
         count = kb + mb * 1024 + gb * 1024 * 1024
         self.run('dd if=/dev/urandom of={file} bs=1024 count={count}'.
 
=== modified file 'ubuntu_system_tests/tests/test_mtp.py'
--- ubuntu_system_tests/tests/test_mtp.py	2015-07-15 11:06:17 +0000
+++ ubuntu_system_tests/tests/test_mtp.py	2015-07-17 19:25:19 +0000
@@ -22,26 +22,14 @@
 import logging
 import os
 
-from ubuntu_system_tests import config
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers.mtp import MTPObjFactory, MTPHelper
 from ubuntu_system_tests.helpers import ssh
 from ubuntu_system_tests.helpers.scopes import music
 from ubuntu_system_tests.helpers.unity8.dash import get_dash
 
 from ubuntu_system_tests.tests import base
 
-TEMP_DIR = '/tmp'
-DEFAULT_XDG_RUNTIME_DIR = '/run/user/1000'
-
-MUSIC = "Music"
-MUSIC_DIR = os.path.join(os.path.expanduser("~"), MUSIC)
-DOCS = "Documents"
-DOCS_DIR = os.path.join(os.path.expanduser("~"), DOCS)
-PICTURES = "Pictures"
-PICTURES_DIR = os.path.join(os.path.expanduser("~"), PICTURES)
-VIDEOS = "Videos"
-VIDEOS_DIR = os.path.join(os.path.expanduser("~"), VIDEOS)
-
 FileMusicDesc = namedtuple('FileMusicDesc', ['file', 'album'])
 logger = logging.getLogger(__name__)
 songs_album_mp3 = ['song_1.mp3', 'song_2.mp3', 'song_3.mp3']
@@ -57,108 +45,17 @@
 }
 
 
-class MTPFile:
-    """ This class is a data model which represents a file to be copied
-    through mtp
-    """
-    def __init__(self, remote_helper):
-        self.remote_helper = remote_helper
-        self.local_path = ""
-        self.remote_src_path = ""
-        self.remote_dst_path = ""
-        self.sha1 = ""
-
-    @property
-    def name(self):
-        return os.path.basename(self.local_path) or ""
-
-    def clean_file(self):
-        if self.local_path:
-            fs.delete_file(self.local_path)
-        if self.remote_src_path:
-            self.remote_helper.remove_file(self.remote_src_path)
-        if self.remote_dst_path:
-            self.remote_helper.remove_file(self.remote_dst_path)
-
-    def remote_copy(self):
-        if not self.remote_src_path or not self.remote_dst_path:
-            raise RuntimeError("Remote copy cannot be done, it is required to "
-                               "define src and dst paths,")
-        logger.info("Copying remote file from {src_path} to {dst_path}".
-                    format(src_path=self.remote_src_path,
-                           dst_path=self.remote_dst_path))
-        self.remote_helper.copy_file(self.remote_src_path,
-                                     self.remote_dst_path)
-
-    def get_remote_dst_sha1(self):
-        if not self.remote_dst_path:
-            raise RuntimeError("Attribute remote_dst_path has to de defined")
-        return self.remote_helper.get_sha1(self.remote_dst_path)
-
-
 class MTPTest(base.BaseUbuntuSystemTestCase):
     """This Class tests the mtp protocol"""
 
     def setUp(self):
         super().setUp()
 
-        self.config_stack = config.get_device_config_stack()
         self.unity_proxy = self.restart_unity()
-        self.remote_helper = ssh.LinuxRemoteHelper(
-            self.config_stack.get('ssh_ip'),
-            self.config_stack.get('ssh_user'),
-            self.config_stack.get('ssh_password'))
+        self.remote_helper = ssh.LinuxRemoteHelper()
         self.addCleanup(self.remote_helper.close)
-        self.mtp_dir = self.calculate_device_mtp_dir()
-
-    def create_random_file(self, dir, ext='', sha1=True):
-        file = MTPFile(self.remote_helper)
-        file.local_path = fs.create_random_file(dir, ext)
-        if sha1:
-            file.sha1 = fs.calculate_file_sha1(file.local_path)
-        self.addCleanup(file.clean_file)
-        return file
-
-    def get_first_elem_in_dir_command(self, path):
-        """Command to retrieve the first element in a dir"""
-        return 'ls {} | sort -n | head -1'.format(path)
-
-    def get_device_mtp_dir(self, dir_to_map, filename):
-        """ Determine the full_path in the ubuntu host machine which maps the
-        file and directory in the device
-        :param dir_to_map: The directory to map
-        :param filename: The name of the file to be mapped
-        :return: the full path that maps the dir_to_map and filename in the
-                 device
-        """
-        cmd_line = "python3 -c \"import glob; import os; " \
-                   "print(glob.glob(os.getenv('XDG_RUNTIME_DIR', " \
-                   "'{default}') + '/gvfs/*/*/{dir}/{filename}')[0])\"".\
-            format(default=DEFAULT_XDG_RUNTIME_DIR,
-                   dir=dir_to_map,
-                   filename=filename)
-
-        file_path = self.remote_helper.run(cmd_line).strip()
-        if file_path:
-            return os.path.dirname(file_path)
-        return None
-
-    def calculate_device_mtp_dir(self):
-        """ Get the path in the ubuntu host machine which maps to the mtp dir.
-        Use a random file to identify the device internal storage destination.
-        """
-        file = fs.create_random_file(DOCS_DIR, ext='.tmp')
-        self.addCleanup(os.remove, file)
-        docs_mtp_dir = self.get_device_mtp_dir(DOCS, os.path.basename(file))
-        return os.path.dirname(docs_mtp_dir)
-
-    def get_device_mtp_path(self, *paths):
-        """ Retrieve the mtp path following the desired paths
-        :param paths: A list of subdir to the destination path
-        :return: The mtp path already escaped to the destination path
-        """
-        dir = os.path.join(self.mtp_dir, *paths)
-        return '"' + dir + '"'
+        self.factory = MTPObjFactory(self.remote_helper, self.addCleanup)
+        self.mtp_helper = MTPHelper(self.remote_helper)
 
     def verify_music_album_is_shown(self, album):
         """ Determines if there is an album with the desired name in the music
@@ -169,33 +66,6 @@
         music_scope = music.MusicScope(get_dash().open_music_scope())
         self.assertTrue(music_scope.is_album(album))
 
-    def create_remote_dir(self, parent_dir):
-        """
-        Create a dir with random name in the remote host
-        :param parent_dir: the name of the parent dir where the new dir has to
-        be created
-        :return: the dir name and its full path
-        """
-        dir_name = fs.get_random_string()
-        dir_path = os.path.join(parent_dir, dir_name)
-        self.remote_helper.create_dir(dir_path)
-
-        return dir_name, dir_path
-
-    def copy_file_to_remote_host(self, file_path, remote_dir):
-        """ Copy a local file to a remote host
-        :param file_path: the local dire where the file is located
-        :param remote_dir: the remote dir where the file is going to be copied
-        :return: the full path of the file in the remote host
-        """
-        dst_file = os.path.join(remote_dir, os.path.basename(file_path))
-        logger.info("Copying local file {file_path} to remote host on "
-                    "{dst_file}".format(file_path=file_path,
-                                        dst_file=dst_file))
-        self.remote_helper.copy(file_path, dst_file)
-        self.addCleanup(self.remote_helper.remove_file, dst_file)
-        return dst_file
-
     def verify_same_files(self, src_files, dst_files):
         """ Verify both file lists contains the same files
         :param src_files: list of src file names
@@ -210,67 +80,33 @@
         :param dst_files: list of files copied to the copied in the device
         """
         for file in dst_files:
-            self.assertTrue(fs.compare_files(src_file,
-                                             os.path.join(dst_dir, file)))
-
-    def replicate_file(self, src_file, dst_dir, dst_files):
-        """ Copy the src file to the dst directory with the different names
-        stored in the dst_files variable
-        :param src_file: the source file to replicate
-        :param dst_dir: the destination directory to copy the files
-        :param dst_files: the target names to use
-        """
-        for file in dst_files:
-            self.remote_helper.copy_file(src_file,
-                                         os.path.join(dst_dir, file))
-
-    def verify_file_copied(self, base_dir, file_name):
-        """ Verify the file was copied to the base directory
-        :param base_dir: the directory where the file has to be copied
-        :param file_name: the name of the copied file
-        :return: the destination path where the file was copied
-        """
-        copied_file = os.path.join(base_dir, file_name)
-        self.assertTrue(os.path.isfile(copied_file))
-        self.addCleanup(os.remove, copied_file)
-        return copied_file
-
-    def verify_dir_copied(self, base_dir, dir_name):
-        """ Verify the dir was copied to the base directory
-        :param base_dir: the directory where the dir name has to be copied
-        :param dir_name: the name of the copied dir
-        :return: the destination path where the dir was copied
-        """
-        copied_dir = os.path.join(base_dir, dir_name)
-        self.assertTrue(os.path.isdir(copied_dir))
-        self.addCleanup(fs.remove_dir, copied_dir)
-        return copied_dir
-
-    def prepare_music_albums(self, src_mp3_file, src_ogg_file):
+            self.assertTrue(src_file.compare(os.path.join(dst_dir, file)))
+
+    def prepare_music_albums(self, mp3_file, ogg_file):
         """ Prepare the albums in the remote host with the song to be copied
          It creates one dir with two albums inside, each album has 3 songs with
          mp3 and ogg formats respectively
-        :return: the
         """
 
         # Create music albums structure in the host machine
-        (albums_name, albums_dir) = self.create_remote_dir(TEMP_DIR)
-        (album_mp3_name, album_mp3_dir) = self.create_remote_dir(albums_dir)
-        (album_ogg_name, album_ogg_dir) = self.create_remote_dir(albums_dir)
-        self.addCleanup(self.remote_helper.remove_dir, albums_dir)
+        albums_dir = self.factory.create_remote_dir()
+        album_mp3_dir = self.factory.create_remote_dir(
+            path=albums_dir.remote_src_path)
+        album_ogg_dir = self.factory.create_remote_dir(
+            path=albums_dir.remote_src_path)
 
         # Copy the music files to the ubuntu host machine
-        dst_tmp_mp3_file = \
-            self.copy_file_to_remote_host(src_mp3_file, TEMP_DIR)
-        dst_tmp_ogg_file = \
-            self.copy_file_to_remote_host(src_ogg_file, TEMP_DIR)
+        mp3_file.send_to_host(fs.DIR_TEMP)
+        ogg_file.send_to_host(fs.DIR_TEMP)
 
         # Copy the music files in the ubuntu host machine to the albums
         # several times with different names and formats
-        self.replicate_file(dst_tmp_mp3_file, album_mp3_dir, songs_album_mp3)
-        self.replicate_file(dst_tmp_ogg_file, album_ogg_dir, songs_album_ogg)
+        self.mtp_helper.replicate_file(mp3_file, album_mp3_dir,
+                                       songs_album_mp3)
+        self.mtp_helper.replicate_file(ogg_file, album_ogg_dir,
+                                       songs_album_ogg)
 
-        return albums_name, albums_dir, album_mp3_name, album_ogg_name
+        return albums_dir, album_mp3_dir, album_ogg_dir
 
     def verify_copied_files(self, seed_file, original_files, copied_dir):
         """ Verify all the files have been copied correctly to the dst
@@ -307,27 +143,33 @@
 
         # Prepare the albums structure in the remote machine previous to be
         # copied to the device
-        src_mp3_file = os.path.join(fs.DIR_TEST_DATA_AUDIO,
-                                    test_data.get('mp3_file').file)
-        src_ogg_file = os.path.join(fs.DIR_TEST_DATA_AUDIO,
-                                    test_data.get('ogg_file').file)
-        albums_name, albums_dir, album_mp3_name, album_ogg_name = \
-            self.prepare_music_albums(src_mp3_file, src_ogg_file)
+        mp3_file = self.factory.create_file(
+            os.path.join(fs.DIR_TEST_DATA_AUDIO,
+                         test_data.get('mp3_file').file))
+        ogg_file = self.factory.create_file(
+            os.path.join(fs.DIR_TEST_DATA_AUDIO,
+                         test_data.get('ogg_file').file))
+
+        albums_dir, album_mp3_dir, album_ogg_dir = \
+            self.prepare_music_albums(mp3_file, ogg_file)
 
         # Copy the albums directory from the temporal dir in the ubuntu host
         # machine to the dir which maps the music dir in the device
-        device_mtp_albums_path = self.get_device_mtp_path(MUSIC, albums_name)
-        self.remote_helper.copy_dir(albums_dir, device_mtp_albums_path)
+        mtp_albums_path = self.mtp_helper.get_mtp_path(fs.DIR_MUSIC,
+                                                       albums_dir.name)
+        albums_dir.remote_copy(mtp_albums_path)
 
         # Verify the albums have ben copied to the music folder
-        copied_albums = self.verify_dir_copied(MUSIC_DIR, albums_name)
+        albums_dir.local_dst_path = os.path.join(fs.DIR_HOME_MUSIC,
+                                                 albums_dir.name)
+        self.assertTrue(os.path.isdir(albums_dir.local_dst_path))
 
-        copied_album_mp3 = os.path.join(copied_albums, album_mp3_name)
-        self.verify_songs(src_mp3_file, songs_album_mp3, copied_album_mp3,
+        dst_path = os.path.join(albums_dir.local_dst_path, album_mp3_dir.name)
+        self.verify_songs(mp3_file, songs_album_mp3, dst_path,
                           test_data.get('mp3_file').album)
 
-        copied_album_ogg = os.path.join(copied_albums, album_ogg_name)
-        self.verify_songs(src_ogg_file, songs_album_ogg, copied_album_ogg,
+        dst_path = os.path.join(albums_dir.local_dst_path, album_ogg_dir.name)
+        self.verify_songs(ogg_file, songs_album_ogg, dst_path,
                           test_data.get('ogg_file').album)
 
     def test_copy_large_number_of_files(self):
@@ -336,53 +178,43 @@
         original.
         """
         amount = 100
-        src_file_name = test_data.get('text_file')
-        src_file = os.path.join(fs.DIR_TEST_DATA_TEXT, src_file_name)
+        myfile = self.factory.create_file(
+            os.path.join(fs.DIR_TEST_DATA_TEXT, test_data.get('text_file')))
 
         # Create the dir to store the files in the host machine
-        (dir_name, dir_path) = self.create_remote_dir(TEMP_DIR)
-        self.addCleanup(self.remote_helper.remove_dir, dir_path)
+        mydir = self.factory.create_remote_dir()
 
         # Copy the src file to the ubuntu host machine
-        dst_tmp_file = self.copy_file_to_remote_host(src_file, TEMP_DIR)
+        myfile.send_to_host(fs.DIR_TEMP)
 
         # Replicate the src file 100 times
-        original_files = [src_file_name + "_" + str(i) for i in range(amount)]
-        self.replicate_file(dst_tmp_file, dir_path, original_files)
+        original_files = [myfile.name + "_" + str(i) for i in range(amount)]
+        self.mtp_helper.replicate_file(myfile, mydir, original_files)
 
         # Copy the directory from the temporal dir in the ubuntu host
         # machine to the dir which maps the documents dir in the device
-        device_mtp_dir_path = self.get_device_mtp_path(DOCS, dir_name)
-        logger.info("Copying remote files to mtp directory from {src_path} to "
-                    "{mtp_path}".format(src_path=dir_path,
-                                        mtp_path=device_mtp_dir_path))
-        self.remote_helper.copy_dir(dir_path, device_mtp_dir_path)
+        mydir.remote_copy(self.mtp_helper.get_mtp_path(fs.DIR_DOCUMENTS,
+                                                       mydir.name))
 
         # Verify the files have ben copied correctly to the destiation
-        copied_dir = self.verify_dir_copied(DOCS_DIR, dir_name)
-        self.verify_copied_files(src_file, original_files, copied_dir)
+        mydir.local_dst_path = os.path.join(fs.DIR_HOME_DOCUMENTS, mydir.name)
+        self.assertTrue(os.path.isdir(mydir.local_dst_path))
+        self.verify_copied_files(myfile, original_files, mydir.local_dst_path)
 
     def _test_copy_big_file(self, kb=0, mb=0, gb=0):
         # Create the remote file with random content and get the sha1 digest
-        file_name = fs.get_random_string() + ".tmp"
-        file_path = os.path.join(TEMP_DIR, file_name)
-
-        self.remote_helper.create_random_file(file_path, kb=kb, mb=mb, gb=gb)
-        self.addCleanup(self.remote_helper.remove_file, file_path)
-        file_sha1 = self.remote_helper.get_sha1(file_path).strip()
-
+        file = self.factory.create_remote_file(ext='.tmp', kb=kb, mb=mb, gb=gb)
         # Copy the directory from the temporal dir in the ubuntu host
         # machine to the dir which maps the documents dir in the device
-        device_mtp_dst_path = self.get_device_mtp_path(DOCS, file_name)
-        logger.info("Copying remote files to mtp directory from {src_path} to "
-                    "{mtp_path}".format(src_path=file_path,
-                                        mtp_path=device_mtp_dst_path))
-        self.remote_helper.copy_file(file_path, device_mtp_dst_path)
+        file.remote_copy(self.mtp_helper.get_mtp_path(fs.DIR_DOCUMENTS,
+                                                      file.name))
 
         # Verify the files have ben copied correctly to the destiation
-        copied_file = self.verify_file_copied(DOCS_DIR, file_name)
-        copied_sha1 = fs.calculate_file_sha1(copied_file)
-        self.assertEqual(file_sha1, copied_sha1)
+        file.local_dst_path = os.path.join(fs.DIR_HOME_DOCUMENTS, file.name)
+        self.assertTrue(os.path.isfile(file.local_dst_path))
+
+        copied_sha1 = fs.calculate_file_sha1(file.local_dst_path)
+        self.assertEqual(file.sha1, copied_sha1)
 
     def test_copy_big_1gb_file(self):
         """ Copy a big file (almost 2GB) through mtp and check the file has
@@ -415,21 +247,24 @@
         """
 
         # Create random source data and calculate the sha1 digest
-        song = self.create_random_file(MUSIC_DIR, ext='.mp3')
-        song.remote_src_path = self.get_device_mtp_path(MUSIC, song.name)
-
-        video = self.create_random_file(VIDEOS_DIR, ext='.avi')
-        video.remote_src_path = self.get_device_mtp_path(VIDEOS, video.name)
-
-        picture = self.create_random_file(PICTURES_DIR, ext='.jpg')
-        picture.remote_src_path = self.get_device_mtp_path(PICTURES,
-                                                           picture.name)
+        song = self.factory.create_random_file(fs.DIR_HOME_MUSIC, ext='.mp3')
+        song.remote_src_path = \
+            self.mtp_helper.get_mtp_path(fs.DIR_MUSIC, song.name)
+
+        video = self.factory.create_random_file(fs.DIR_HOME_VIDEOS, ext='.avi')
+        video.remote_src_path = \
+            self.mtp_helper.get_mtp_path(fs.DIR_VIDEOS, video.name)
+
+        picture = self.factory.create_random_file(fs.DIR_HOME_PICTURES,
+                                                  ext='.jpg')
+        picture.remote_src_path = \
+            self.mtp_helper.get_mtp_path(fs.DIR_PICTURES, picture.name)
 
         files = [song, video, picture]
 
         # Set destination path to files
         for file in files:
-            file.remote_dst_path = os.path.join(TEMP_DIR, file.name)
+            file.remote_dst_path = os.path.join(fs.DIR_TEMP, file.name)
 
         # Copy the files from mtp to tmp directory and verify the sha1
         for file in files:
@@ -440,4 +275,4 @@
         # Remove remote files and verify the files were deleted in the device
         for file in files:
             self.remote_helper.remove_file(file.remote_src_path)
-            self.assertFalse(os.path.isfile(file.local_path))
+            self.assertFalse(os.path.isfile(file.local_src_path))