#!/usr/bin/env python
#
# $Id: test_packagetree.py,v 1.2 2003/01/01 13:48:47 doughellmann Exp $
#
# Copyright 2002 Doug Hellmann.
#
#
#                         All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of Doug
# Hellmann not be used in advertising or publicity pertaining to
# distribution of the software without specific, written prior
# permission.
#
# DOUG HELLMANN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
# NO EVENT SHALL DOUG HELLMANN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#

"""Tests for packagetree module.

"""

__rcs_info__ = {
    #
    #  Creation Information
    #
    'module_name'  : '$RCSfile: test_packagetree.py,v $',
    'rcs_id'       : '$Id: test_packagetree.py,v 1.2 2003/01/01 13:48:47 doughellmann Exp $',
    'creator'      : 'Doug Hellmann <doug@hellfly.net>',
    'project'      : 'HappyDoc',
    'created'      : 'Sun, 29-Dec-2002 12:41:21 EST',

    #
    #  Current Information
    #
    'author'       : '$Author: doughellmann $',
    'version'      : '$Revision: 1.2 $',
    'date'         : '$Date: 2003/01/01 13:48:47 $',
}
try:
    __version__ = __rcs_info__['version'].split(' ')[1]
except:
    __version__ = '0.0'

#
# Import system modules
#
import os
import unittest

#
# Import Local modules
#
from happydoclib.scanner import Scanner
from happydoclib.packagetree import PackageTree

#
# Module
#


class PackageTreeTestCase(unittest.TestCase):
    
    def testGetInputFilename(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()

        expected_tree = trees[0]
        self.failUnlessEqual(
            expected_tree.getName(),
            'testScanner',
            'First level tree got %s instead of testScanner' % expected_tree.getName(),
            )

        level_one = expected_tree['levelOne']
        self.failUnlessEqual(
            level_one.getName(),
            'levelOne',
            'First sub-level tree got %s instead of levelOne' % level_one.getName(),
            )
        self.failUnlessEqual(level_one.getInputFilename(),
                             'TestCases/testScanner/levelOne',
                             )

        level_two = level_one['levelTwo']
        self.failUnlessEqual(
            level_two.getName(),
            'levelTwo',
            'First sub-level tree got %s instead of levelTwo' % level_two.getName(),
            )
        self.failUnlessEqual(level_two.getInputFilename(),
                             'TestCases/testScanner/levelOne/levelTwo',
                             )

        return
    
    def testGetRelativeFilename(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()

        expected_tree = trees[0]

        actual = expected_tree.getRelativeFilename()
        expected = 'testScanner'
        self.failUnlessEqual(
            actual,
            expected,
            )

        level_one = expected_tree['levelOne']
        actual = level_one.getRelativeFilename()
        expected = os.path.join('testScanner', 'levelOne')
        self.failUnlessEqual(
            actual,
            expected,
            )

        module_one = level_one['one.py']
        actual = module_one.getRelativeFilename()
        expected = os.path.join('testScanner', 'levelOne', 'one.py')
        self.failUnlessEqual(
            actual,
            expected,
            )

        class_one = module_one['One']
        actual = class_one.getRelativeFilename()
        expected = os.path.join('testScanner', 'levelOne', 'one.py', 'One')
        self.failUnlessEqual(
            actual,
            expected,
            )

        level_two = level_one['levelTwo']
        actual = level_two.getRelativeFilename()
        expected = os.path.join('testScanner', 'levelOne', 'levelTwo')
        self.failUnlessEqual(
            actual,
            expected,
            )

        return

    def testPackageTreePath(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]

        dir_one = expected_tree['levelOne']
        dir_one_path = dir_one.getPath()
        self.failUnlessEqual(dir_one_path,
                             ('testScanner',
                              'levelOne',
                              ))

        dir_two = expected_tree['levelOne']['levelTwo']
        dir_two_path = dir_two.getPath()
        self.failUnlessEqual(dir_two_path,
                             ('testScanner',
                              'levelOne',
                              'levelTwo',
                              ))

        module_two = expected_tree['levelOne']['levelTwo']['two.py']

        module_two_path = module_two.getPath()
        self.failUnlessEqual(module_two_path,
                             ('testScanner',
                              'levelOne',
                              'levelTwo',
                              'two.py',
                              ),
                             )
        return
    
    def testPackageTreePath(self):
        cwd = os.getcwd()
        input_dir = os.path.join(cwd, 'TestCases/testScanner')
        scanner = Scanner([input_dir])

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]

        module_two = expected_tree['levelOne']['levelTwo']['two.py']

        module_two_path = module_two.getPath(1)
        self.failUnlessEqual(module_two_path,
                             (input_dir,
                              'levelOne',
                              'levelTwo',
                              'two.py',
                              ),
                             )
        return

    def testPackageTreeIgnore(self):
        scanner = Scanner(['TestCases/testScanner'], ['ignoreme.py'])

        trees = scanner.getPackageTrees()
        level_one = trees[0]['levelOne']

        try:
            ignoring = level_one['ignoreme.py']
        except KeyError:
            pass
        else:
            self.fail('Still have ignoreme.py')

        return

    def testPackageTreeIgnoreTestFiles(self):
        scanner = Scanner(['happydoclib'], ['^tests.py$',
                                            '^test_.*py$',
                                            ])
        
        trees = scanner.getPackageTrees()
        level_one = trees[0]

        for name in ('tests.py',
                     'test_scanner.py',
                     ):
            try:
                ignoring = level_one[name]
            except KeyError:
                pass
            else:
                self.fail('Still have %s' % name)
            
        return

    def testPackageTreeName(self):
        tree = PackageTree(None, 'tree1')
        self.failUnlessEqual('tree1', tree.getName(),
                             'Names do not match.')
        return

    def testPackageTreeNameNotCanonical(self):
        tree = PackageTree(None, '/full/path/to/tree1')
        self.failUnlessEqual('tree1', tree.getName(),
                             'Names do not match.')
        return

    def testPackageTreeNameCanonical(self):
        tree = PackageTree(None, '/full/path/to/tree1')
        self.failUnlessEqual('/full/path/to/tree1', tree.getCanonicalName(),
                             'Names do not match.')
        return
    
    def testPackageTreeParent(self):
        tree = PackageTree(None, 'tree1')
        self.failUnlessEqual(None, tree.getParent(),
                             'Parents do not match.')
        return
    
class PackageTreeGetSubNodesTestCase(unittest.TestCase):
    
    def testGetTextSubNodes(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()

        expected_tree = trees[0]
        self.failUnlessEqual(
            expected_tree.getName(),
            'testScanner',
            'First level tree got %s instead of testScanner' % expected_tree.getName(),
            )

        level_one = expected_tree['levelOne']
        
        subnodes = level_one.getSubNodes('text/plain')
        actual = len(subnodes)
        names = [ subnode.getName() for subnode in subnodes ]
        expected = 1
        self.failUnlessEqual(
            actual,
            expected,
            'Got %s subnodes (%s), expected %s' % (actual,
                                                   names,
                                                   expected,
                                                   )
            )
        
        actual = subnodes[0].getName()
        expected = 'README.txt'
        self.failUnlessEqual(actual, expected)

        return
    
    def testGetHtmlSubNodes(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()

        expected_tree = trees[0]
        self.failUnlessEqual(
            expected_tree.getName(),
            'testScanner',
            'First level tree got %s instead of testScanner' % expected_tree.getName(),
            )

        level_one = expected_tree['levelOne']
        
        subnodes = level_one.getSubNodes('text/html')
        actual = len(subnodes)
        names = [ subnode.getName() for subnode in subnodes ]
        expected = 1
        self.failUnlessEqual(
            actual,
            expected,
            'Got %s subnodes (%s), expected %s' % (actual,
                                                   names,
                                                   expected,
                                                   )
            )
        
        actual = subnodes[0].getName()
        expected = 'Existing.html'
        self.failUnlessEqual(actual, expected)

        return
    
    def testGetPythonSubNodes(self):
        scanner = Scanner(['TestCases/testScanner'])

        trees = scanner.getPackageTrees()

        expected_tree = trees[0]
        self.failUnlessEqual(
            expected_tree.getName(),
            'testScanner',
            'First level tree got %s instead of testScanner' % expected_tree.getName(),
            )

        level_one = expected_tree['levelOne']
        
        subnodes = level_one.getSubNodes('text/x-python')
        actual = len(subnodes)
        names = [ subnode.getName() for subnode in subnodes ]
        expected = 3
        self.failUnlessEqual(
            actual,
            expected,
            'Got %s subnodes (%s), expected %s' % (actual,
                                                   names,
                                                   expected,
                                                   )
            )
        
        return

    
class PackageTreeRelativePathTestCase(unittest.TestCase):

    def setUp(self):
        cwd = os.getcwd()
        input_dir = os.path.join(cwd, 'TestCases/testScanner')
        scanner = Scanner([input_dir])

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]
        self.expected_tree = expected_tree
        return

    def testSelf(self):
        target = self.expected_tree['levelOne']['levelTwo']['two.py']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']

        relative_path = start.getPathToNode(target)
        self.failUnlessEqual(relative_path,
                             (),
                             )
        return
    
    def testParentDirOfModuleDir(self):
        target = self.expected_tree['levelOne']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']

        relative_path = start.getPathToNode(target)
        self.failUnlessEqual(relative_path,
                             ('..',
                              '..',
                              'levelOne',
                              ),
                             )
        return
    
    def testModuleSameDir(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['ignoreme.py']

        relative_path = start.getPathToNode(target)
        self.failUnlessEqual(relative_path,
                             ('one.py',
                              ),
                             )
        return
    
    def testModuleParentDir(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']

        relative_path = start.getPathToNode(target)
        self.failUnlessEqual(relative_path,
                             ('..',
                              'one.py',
                              ),
                             )
        return
    
    def testParentDirOfDir(self):
        target = self.expected_tree['levelOne']
        start = self.expected_tree['levelOne']['levelTwo']

        relative_path = start.getPathToNode(target)
        self.failUnlessEqual(relative_path,
                             ('..',
                              '..',
                              'levelOne',
                              ),
                             )
        return
        

class PackageTreeSummaryAndDocStringTests(unittest.TestCase):

    def setUp(self):
        input_dir = os.path.join('TestCases', 'testScanner')
        output_dir = '/tmp/foo'
        
        scanner = Scanner([input_dir])

        self.scanner = scanner
        return

    def tearDown(self):
        del self.scanner
        return
    
    def testGetReadmeTextForDirectoryInit(self):
        trees = self.scanner.getPackageTrees()
        expected_tree = trees[0]['readme_from_init']

        actual, format = expected_tree.getDocStringAndFormat()

        expected_format = 'StructuredText'
        expected = 'This is the __init__.py file for readme_from_init.'
        
        self.failUnlessEqual(actual, expected)
        return
    
    def testGetReadmeTextForDirectoryDotTxt(self):
        trees = self.scanner.getPackageTrees()
        expected_tree = trees[0]['readme_from_readme']

        actual, format = expected_tree.getDocStringAndFormat()

        expected_format = 'StructuredText'
        expected = 'This is the README.txt file for readme_from_readme.\n'
        
        self.failUnlessEqual(actual, expected)
        return
    
    def testGetReadmeTextForDirectoryDotStx(self):
        trees = self.scanner.getPackageTrees()
        expected_tree = trees[0]['readme_from_stx']

        actual, format = expected_tree.getDocStringAndFormat()

        expected_format = 'StructuredText'
        expected = 'This is the README.stx file for readme_from_stx.\n'
        
        self.failUnlessEqual(actual, expected)
        return
    
class PackageTreeFindNodeTestCase(unittest.TestCase):

    def setUp(self):
        cwd = os.getcwd()
        input_dir = os.path.join(cwd, 'TestCases/testScanner')
        scanner = Scanner([input_dir])
        self.scanner = scanner

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]
        self.expected_tree = expected_tree
        return

    def _testFind(self, name, start, target):
        found = start.findNodeFromDottedName(name)
        if found is None:
            self.fail('Did not find anything for %s' % name)
        self.failUnlessEqual(found, target)
        return found
    
    def testFindSelf(self):
        self._testFind('levelOne',
                       self.expected_tree['levelOne'],
                       self.expected_tree['levelOne'],
                       )
        return
     
    def testFindChild(self):
        self._testFind('levelTwo',
                       self.expected_tree['levelOne'],
                       self.expected_tree['levelOne']['levelTwo'],
                       )
        return
     
    def testFindChildClass(self):
        self._testFind('One',
                       self.expected_tree['levelOne']['one.py'],
                       self.expected_tree['levelOne']['one.py']['One'],
                       )
        return
     
    def testFindSelfDotChild(self):
        self._testFind('levelOne.levelTwo',
                       self.expected_tree['levelOne'],
                       self.expected_tree['levelOne']['levelTwo'],
                       )
        return
    
    def testFindParent(self):
        self._testFind('levelOne',
                       self.expected_tree['levelOne']['levelTwo'],
                       self.expected_tree['levelOne'],
                       )
        return
    
    def testFindSibling(self):
        self._testFind('readme_from_readme',
                       self.expected_tree['levelOne'],
                       self.expected_tree['readme_from_readme'],
                       )
        return
    
    def testFindSiblingClass(self):
        self._testFind('AnotherOne',
                       self.expected_tree['levelOne']['one.py']['One'],
                       self.expected_tree['levelOne']['one.py']['AnotherOne'],
                       )
        return
    
    def testFindAunt(self):
        self._testFind('readme_from_readme',
                       self.expected_tree['levelOne']['levelTwo'],
                       self.expected_tree['readme_from_readme'],
                       )
        return
    
    def testFindNeice(self):
        self._testFind('levelOne.levelTwo',
                       self.expected_tree['readme_from_readme'],
                       self.expected_tree['levelOne']['levelTwo'], 
                      )
        return
    
    def testFindNotThere(self):
        name = 'levelOne.levelTwo.notThereAtAll'
        start = self.expected_tree['readme_from_readme']
        found = start.findNodeFromDottedName(name)
        
        if found is not None:
            self.fail('Found something unexpected')
        return

    def testFindModuleNameMatchesClassName(self):
        cwd = os.getcwd()
        input_dir = cwd
        scanner = Scanner([input_dir], ['TestOutput', 'TestCases'])
        self.scanner = scanner

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]

        hdl_package = expected_tree['happydoclib']
        cla_module = hdl_package['CommandLineApp.py']
        cla_class = cla_module['CommandLineApp']
        
        name = 'happydoclib.CommandLineApp.CommandLineApp'
        start = expected_tree['happydoclib']['CommandLineApp.py']['TestApp']

        self._testFind(name, start, cla_class)
        return
    
if __name__ == '__main__':
    unittest.main()