path: root/config/tests/makefiles/autodeps/check_mkdir.tpy

#!/usr/bin/env python
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
#

import os
import sys
import tempfile

from subprocess import call
from shutil     import rmtree

import logging
import unittest


def banner():
    """
    Display interpreter and system info for the test env
    """
    print '*' * 75
    cmd = os.path.basename(__file__)
    print "%s: python version is %s" % (cmd, sys.version)
    print '*' * 75


def myopts(vals):
    """
    Storage for extra command line args passed.

    Returns:
    hash - argparse::Namespace object values
    """

    if not hasattr(myopts, 'vals'):
        if 'argparse' in sys.modules:
            tmp = { } # key existance enables unittest module debug
        else:
            tmp = { 'debug': False, 'verbose': False }

        for k in dir(vals):
            if k[0:1] == '_':
                continue
            tmp[k] = getattr(vals, k)
        myopts.vals = tmp

    return myopts.vals
    

def path2posix(src):
    """
    Normalize directory path syntax

    Keyword arguments:
    src - path to normalize

    Returns:
    scalar - a file path with drive separators and windows slashes removed

    Todo:
    move to {build,config,tools,toolkit}/python for use in a library
    """

    ## (drive, tail) = os.path.splitdrive(src)
    ## Support path testing on all platforms
    drive = ''
    winpath = src.find(':')
    if -1 != winpath and 10 > winpath:
        (drive, tail) = src.split(':', 1)

    if drive:
        todo = [ '', drive.rstrip(':').lstrip('/').lstrip('\\') ]
        todo.extend( tail.lstrip('/').lstrip('\\').split('\\') ) # c:\a => [a]
    else: # os.name == 'posix'
        todo = src.split('\\')

    dst = '/'.join(todo)
    return dst
    

def checkMkdir(work, debug=False):
    """
    Verify arg permutations for directory mutex creation.

    Keyword arguments:
    None

    Returns:
    Exception on error

    Note:
    Exception() rather than self.assertTrue() is used in this test
    function to enable scatch cleanup on test exit/failure conditions.
    Not guaranteed by python closures on early exit.
    """

    logging.debug("Testing: checkMkdir")

    # On Windows, don't convert paths to POSIX
    skipposix = sys.platform == "win32"
    if skipposix:
        path = os.path.abspath(__file__)
        dirname_fun = os.path.dirname
    else:
        path = path2posix(os.path.abspath(__file__))
        import posixpath
        dirname_fun = posixpath.dirname

    src = dirname_fun(path)
    # root is 5 directories up from path
    root = reduce(lambda x, _: dirname_fun(x), xrange(5), path)

    rootP = path2posix(root)
    srcP  = path2posix(src)
    workP = path2posix(work)

    # C:\foo -vs- /c/foo
    # [0] command paths use /c/foo
    # [1] os.path.exists() on mingw() requires C:\
    paths = [
        "mkdir_bycall", # function generated
        "mkdir_bydep",  # explicit dependency
        "mkdir_bygen",  # by GENERATED_DIRS macro
    ]

    ## Use make from the parent "make check" call when available
    cmd = { 'make': 'make' }
    shell0 = os.environ.get('MAKE')
    if shell0:
        shell = os.path.splitext(shell0)[0] # strip: .exe, .py
        if -1 != shell.find('make'):
            print "MAKE COMMAND FOUND: %s" % (shell0)
            cmd['make'] = shell0 if skipposix else path2posix(shell0)

    args = []
    args.append('%s' % (cmd['make']))
    args.append('-C %s'                % (work if skipposix else workP))
    args.append("-f %s/testor.tmpl"    % (src if skipposix else srcP))
    args.append('topsrcdir=%s'         % (root if skipposix else rootP))
    args.append('deps_mkdir_bycall=%s' % paths[0])
    args.append('deps_mkdir_bydep=%s'  % paths[1])
    args.append('deps_mkdir_bygen=%s'  % paths[2])
    args.append('checkup') # target

    # Call will fail on mingw with output redirected ?!?
    if debug:
        pass
    if False: # if not debug:
        args.append('>/dev/null')

    cmd = '%s' % (' '.join(args))
    logging.debug("Running: %s" % (cmd))
    rc = call(cmd, shell=True)
    if rc:
        raise Exception("make failed ($?=%s): cmd=%s" % (rc, cmd))

    for i in paths:
        path = os.path.join(work, i)
        logging.debug("Did testing mkdir(%s) succeed?" % (path))
        if not os.path.exists(path):
            raise Exception("Test path %s does not exist" % (path))


def parseargs():
    """
    Support additional command line arguments for testing
    
    Returns:
    hash - arguments of interested parsed from the command line
    """

    opts = None
    try:
        import argparse2
        parser = argparse.ArgumentParser()
        parser.add_argument('--debug',
                            action="store_true",
                            default=False,
                            help='Enable debug mode')
        # Cannot overload verbose, Verbose: False enables debugging
        parser.add_argument('--verbose',
                            action="store_true",
                            default=False,
                            help='Enable verbose mode')
        parser.add_argument('unittest_args',
                            nargs='*'
                            # help='Slurp/pass remaining args to unittest'
                            )
        opts = parser.parse_args()

    except ImportError:
        pass

    return opts


class TestMakeLogic(unittest.TestCase):
    """
    Test suite used to validate makefile library rules and macros
    """

    def setUp(self):
        opts = myopts(None) # NameSpace object not hash
        self.debug   = opts['debug']
        self.verbose = opts['verbose']

        if self.debug:
            logging.basicConfig(level=logging.DEBUG)

        if self.verbose:
            print
            print "ENVIRONMENT DUMP:"
            print '=' * 75
            for k,v in os.environ.items():
                print "env{%s} => %s" % (k, v)
            print


    def test_path2posix(self):

        todo = {
            '/dev/null'     : '/dev/null',
            'A:\\a\\b\\c'   : '/A/a/b/c',
            'B:/x/y'        : '/B/x/y',
            'C:/x\\y/z'     : '/C/x/y/z',
            '//FOO/bar/tans': '//FOO/bar/tans',
            '//X\\a/b\\c/d' : '//X/a/b/c/d',
            '\\c:mozilla\\sandbox': '/c/mozilla/sandbox',
        }

        for val,exp in todo.items():
            found = path2posix(val)
            tst = "posix2path(%s): %s != %s)" % (val, exp, found)
            self.assertEqual(exp, found, "%s: invalid path detected" % (tst))


    def test_mkdir(self):
        """
        Verify directory creation rules and macros
        """

        failed = True

        # Exception handling is used to cleanup scratch space on error
        try:
            work = tempfile.mkdtemp()
            checkMkdir(work, self.debug)
            failed = False
        finally:
            if os.path.exists(work):
                rmtree(work)

        self.assertFalse(failed, "Unit test failure detected")


if __name__ == '__main__':
    banner()
    opts = parseargs()
    myopts(opts)

    if opts:
        if hasattr(opts, 'unittest_args'):
            sys.argv[1:] = opts.unittest_args
        else:
            sys.argv[1:] = []

    unittest.main()