Mercurial > treepkg

# Copyright (C) 2007, 2008 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Support code for the test cases"""

import os
import shutil
from treepkg.util import writefile


def create_temp_dir():
    """Create a temporary directory for the test-suite and return its name.

    The temporary directory is always called temp and is created in the
    directory where the support module is located.

    If the temp directory already exists, just return the name.
    """
    name = os.path.abspath(os.path.join(os.path.dirname(__file__), "temp"))

    # if the directory already exists, we're done
    if os.path.isdir(name):
        return name

    # create the directory
    os.mkdir(name)
    return name


class FileTestMixin:

    """Mixin class for tests that use temporary files.

    Instances of this class create a test-specific sub-directory under
    the main test temp directory.  The name of the sub-directory is the
    return value of the test's id() method.
    """

    _test_specific_directory_created = False

    def create_test_specific_temp_dir(self):
        """Creates the test specific directory and returns its absolute name.
        When this method is called for the first time and the directory
        exists, if is removed, so that a specific test instance always
        starts with an empty directory.
        """
        dirname = os.path.join(create_temp_dir(), self.id())
        if not self._test_specific_directory_created:
            if os.path.exists(dirname):
                shutil.rmtree(dirname)
            os.mkdir(dirname)
            self._test_specific_directory_created = True
        return dirname

    def temp_file_name(self, basename):
        """Returns the full name of the file named basename in the temp. dir.
        """
        return os.path.join(self.create_test_specific_temp_dir(), basename)

    def create_temp_file(self, basename, contents, permissions=None):
        """Creates a file in the temp directory with the given contents.
        The optional parameter permissions should either be None (the
        default) or an int specifying the file permissions (same format
        as the second parameter of os.chmod).  The method returns the
        absolute name of the created file.
        """
        filename = self.temp_file_name(basename)
        file = open(filename, "w")
        file.write(contents)
        file.close()
        if permissions is not None:
            os.chmod(filename, permissions)
        return filename

    def create_temp_dir(self, basename):
        """Creates the directory basename in the temporary directory.
        The method returns the absolute name of the created directory.
        """
        dirname = self.temp_file_name(basename)
        os.mkdir(dirname)
        return dirname

    def create_files(self, directory, filedesc):
        """Creates a hierarchy of directories and files in directory.
        The filedesc parameter should be a sequence of (name, contents)
        pairs or (name, permissions, contents) triples.  Each item of
        the sequence describes one entry of the directory.  If contents
        is an instance of list, the entry is a subdirectory and the
        contents is a list in the same format as filedesc and passed
        recursively to the create_files method.  If contents is a
        string, the new directory entry is a normal file and contents is
        the contents of the file.  The permissions if present, should be
        an int specifying the files permissions (setting permissions
        doesn't work yet for directories).

        The method returns the absolute name of the toplevel directory
        created by the method.
        """
        directory = self.temp_file_name(directory)
        os.makedirs(directory)
        for item in filedesc:
            if len(item) == 3:
                name, permissions, contents = item
            else:
                name, contents = item
                permissions = None # use default permissions
            if isinstance(contents, list):
                # a list as contents indicates a directory
                self.create_files(os.path.join(directory, name), contents)
            else:
                writefile(os.path.join(directory, name), contents, permissions)
        return directory

    def check_file_contents(self, filename, contents):
        """check the contents of a file"""
        self.assertEquals(open(filename).read(), contents)
author	Bjoern Ricks <bricks@intevation.de>
date	Fri, 06 Aug 2010 13:28:47 +0000
parents	e3ab8aca2b08
children