#!/usr/bin/env python
#
# $Id: test_docset_MultiHTMLFile.py,v 1.12 2003/03/16 16:25:58 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 the MultiHTMLFile docset.

"""

__rcs_info__ = {
    #
    #  Creation Information
    #
    'module_name'  : '$RCSfile: test_docset_MultiHTMLFile.py,v $',
    'rcs_id'       : '$Id: test_docset_MultiHTMLFile.py,v 1.12 2003/03/16 16:25:58 doughellmann Exp $',
    'creator'      : 'Doug Hellmann <doug@hellfly.net>',
    'project'      : 'HappyDoc',
    'created'      : 'Sun, 17-Nov-2002 17:31:33 EST',

    #
    #  Current Information
    #
    'author'       : '$Author: doughellmann $',
    'version'      : '$Revision: 1.12 $',
    'date'         : '$Date: 2003/03/16 16:25:58 $',
}
try:
    __version__ = __rcs_info__['version'].split(' ')[1]
except:
    __version__ = '0.0'

#
# Import system modules
#
import os
import unittest

#
#
import happydoclib
from happydoclib import tests
from happydoclib.scanner import Scanner
from happydoclib.docset.docset_MultiHTMLFile import MultiHTMLFileDocSet

#
# Module
#

class MultiHTMLFileDocSetRunTest(tests.HappyDocRunTest):

    PROCTOR_TEST_CATEGORIES = ( 'docset',
                                'MultiHTMLFile',
                                )

    TEST_DOCSET = 'MultiHTMLFile'

#     def testImportStatements(self):
#         self.runHappyDoc( os.path.join( 'TestCases',
#                                         'parseinfo',
#                                         'test_import_statements.py')
#                           )
#         return

class MultiHTMLFileDocSetTestCase(unittest.TestCase):

    def _test(self, inputDir, outputDir, expected):
                   
        scanner = Scanner([inputDir])

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

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

        docset = MultiHTMLFileDocSet(scanner,
                                     'Testing',
                                     outputDir,
                                     )

        actual = docset.getOutputFilenameForPackageTreeNode(module_two)

        self.failUnlessEqual(actual, expected)
        return
        
    def testScanningFromCurrentDirectory(self):
        output_directory = '/foo/bar'
        expected = os.path.join( output_directory,
                                 'testScanner',
                                 'levelOne',
                                 'levelTwo',
                                 'two.html',
                                 )
        
        self._test(inputDir='TestCases/testScanner',
                   outputDir=output_directory,
                   expected=expected,
                   )
        return

    def testScanningFromRoot(self):
        output_directory = '/foo/bar'
        expected = os.path.join( output_directory,
                                 'testScanner',
                                 'levelOne',
                                 'levelTwo',
                                 'two.html',
                                 )
        
        self._test(inputDir=os.path.join( os.getcwd(),
                                          'TestCases/testScanner'),
                   outputDir=output_directory,
                   expected=expected,
                   )
        return

    def testScanningRelativePath(self):
        output_directory = '/foo/bar'
        expected = os.path.join( output_directory,
                                 'testScanner',
                                 'levelOne',
                                 'levelTwo',
                                 'two.html',
                                 )
        
        self._test(inputDir='../HappyDoc3/TestCases/testScanner',
                   outputDir=output_directory,
                   expected=expected,
                   )
        return

    def testPlainTextFile(self):

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

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

        readme = expected_tree['levelOne']['README.txt']

        docset = MultiHTMLFileDocSet(scanner,
                                     'Testing',
                                     output_dir,
                                     )

        actual = docset.getOutputFilenameForPackageTreeNode(readme)

        expected = os.path.join(output_dir, 'testScanner', 'levelOne', 'README.html')
        
        self.failUnlessEqual(actual, expected)
        return
    
    def testNoPath(self):
                   
        input_dir = os.path.join('TestCases', 'testScanner')
        output_dir = '/tmp/foo'
        
        scanner = Scanner([input_dir])

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

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

        docset = MultiHTMLFileDocSet(scanner,
                                     'Testing',
                                     output_dir,
                                     )

        actual = docset.getOutputFilenameForPackageTreeNode(
            module_two,
            includePath=0,
            )

        self.failUnlessEqual(actual, 'two.html')
        return

class GetHREFTestCase(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
        
        self.docset = MultiHTMLFileDocSet(scanner,
                                          'Testing',
                                          '/tmp/foo',
                                          )
        return

    def testSelfHREF(self):
        target = self.expected_tree['levelOne']['levelTwo']['two.py']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']
        
        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'two.html',
                             )
        return
    
    def testParentDirOfModuleDirHREF(self):
        target = self.expected_tree['levelOne']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']
        
        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../../levelOne/index.html',
                             )
        return
    
    def testModuleSameDirHREF(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['ignoreme.py']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'one.html',
                             )
        return
    
    def testClassFromModuleHREF(self):
        target = self.expected_tree['levelOne']['one.py']['One']
        start = self.expected_tree['levelOne']['one.py']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'one.py/One.html',
                             )
        return
    
    def testModuleFromClassHREF(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['one.py']['One']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../one.html',
                             )
        return
    
    def testParentPackageFromClassHREF(self):
        target = self.expected_tree['levelOne']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']['Two']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../../../levelOne/index.html',
                             )
        return
    
    def testParentModuleFromClassHREF(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']['Two']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../../one.html',
                             )
        return
    
    def testClassSameModuleHREF(self):
        target = self.expected_tree['levelOne']['one.py']['One']
        start = self.expected_tree['levelOne']['one.py']['AnotherOne']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'One.html',
                             )
        return

    def testClassSameModuleCLAHREF(self):
        cwd = os.getcwd()
        input_dir = os.path.join(cwd, 'happydoclib')
        scanner = Scanner([input_dir])

        trees = scanner.getPackageTrees()
        expected_tree = trees[0]
        
        docset = MultiHTMLFileDocSet(scanner,
                                     'Testing',
                                     '/tmp/foo',
                                     )

        target = expected_tree['CommandLineApp.py']['CommandLineApp']
        start = expected_tree['CommandLineApp.py']['TestApp']

        href = docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'CommandLineApp.html',
                             )

        
        target = expected_tree['CommandLineApp.py']['CommandLineApp']
        start = expected_tree['CommandLineApp.py']

        href = docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             'CommandLineApp.py/CommandLineApp.html',
                             )
        return
    
    def testClassOtherModuleHREF(self):
        target = self.expected_tree['levelOne']['one.py']['One']
        start = self.expected_tree['levelOne']['ignoreme.py']['IgnoreThisClass']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../one.py/One.html',
                             )
        return
    
    def testModuleParentDirHREF(self):
        target = self.expected_tree['levelOne']['one.py']
        start = self.expected_tree['levelOne']['levelTwo']['two.py']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../one.html',
                             )
        return
    
    def testParentDirOfDirHREF(self):
        target = self.expected_tree['levelOne']
        start = self.expected_tree['levelOne']['levelTwo']

        href = self.docset._computeRelativeHREF(start, target)
        self.failUnlessEqual(href,
                             '../../levelOne/index.html',
                             )
        return
    
    
class GetOutputFilenameTestCase(unittest.TestCase):

    def setUp(self):
        import os
        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
        
        self.docset = MultiHTMLFileDocSet(scanner,
                                          'Testing',
                                          '/tmp/foo',
                                          )
        return

    def testModule(self):
        target = self.expected_tree['levelOne']['one.py']

        filename = self.docset.getOutputFilenameForPackageTreeNode(target)
        self.failUnlessEqual(
            filename,
            os.path.join('/tmp/foo', 'testScanner', 'levelOne', 'one.html'),
            )
        return

    def testClass(self):
        target = self.expected_tree['levelOne']['one.py']['One']

        filename = self.docset.getOutputFilenameForPackageTreeNode(target)
        self.failUnlessEqual(
            filename,
            os.path.join('/tmp/foo', 'testScanner', 'levelOne', 'one.py', 'One.html'),
            )
        return

if __name__ == '__main__':
    unittest.main()