# Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
# Test code for MbcUtils
#

from MbcUtils import *
import testDataMbcUtils as testdata
import unittest
import tempfile
import StringIO

class TestParent(unittest.TestCase):
    """Potential parent test"""

    def TempFile(self, str):
        """Create a temp file. Write given string and return filename.
        Note caller is responsible for deleting the file"""
        tfile = tempfile.mkstemp()
        file = os.fdopen(tfile[0],"w")
        print >> file, str
        file.close() # close the file - we just want the filename then
        return tfile[1] # return filename. Note client expected to delete

    def fixupDirsInExpectedList(self, expectedToFixUp):
        """Convert relative filenames to absolute.
        The returned list returns absolute filenames. Need to convert relelative
        names to absolute so can easily compare."""

        for tupEle in expectedToFixUp:
            mbcFile = tupEle[0]
            baseDir = os.path.dirname(mbcFile)
            for i in range(1,3):
                # tupEle[1] is list of required folders
                # tupEle[2] is list of optional folders
                for j in range(0, len(tupEle[i])):
                    absDir = os.path.abspath(os.path.join(baseDir, tupEle[i][j]))
                    tupEle[i][j] = absDir
            # tupEle[3] is list of tuples of dir and command
            for j in range(0, len(tupEle[3])):
                # note need to tuple to list and back to do this
                lst = list(tupEle[3][j])
                absDir = os.path.abspath(os.path.join(baseDir, lst[0]))
                lst[0] = absDir
                tupEle[3][j] = tuple(lst)
        return expectedToFixUp

class SimpleTest(TestParent):
    """Open and return basic case"""

    def __init__(self, sample, expected):
        super(SimpleTest,self).__init__()
        self.sample = sample
        self.expected = expected
        self.tfileName = None

    def fixExpected(self, fname):
        """change the filename slot in self.expected"""
        # expected is a tuple. Need to convert to list and back.
        # then turn into a single element list so can run through
        # fixupDirsInExpectedList()
        tempList = list(self.expected)
        tempList[0] = fname
        newTuple = tuple(tempList)
        fixedList = self.fixupDirsInExpectedList([newTuple])
        self.expected = fixedList[0]

    def runTest(self):
        """SimpleTest.runTest

        Create temp file with known content. Run parser and compare result
        """
        self.tfileName = self.TempFile(self.sample)
        parser = MbcParser(self.tfileName)
        parser.execute()
        self.fixExpected(self.tfileName)
        result = parser()
        self.assertEquals(result, self.expected,
                        "Result(%s) not same as Expected(%s)"%(result,self.expected))

    def tearDown(self):
        if self.tfileName:
            os.unlink(self.tfileName)

class BadDataTest(SimpleTest):
    """Bad data so should get an exception"""

    def __init__(self, sample, testName):
        super(BadDataTest,self).__init__(sample, [])
        self.__testName = testName

    def runTest(self):
        """BadDataTest.runTest

        Use SimpleTest.runTest. Should throw an exception"""
        self.assertRaises(InvalidInput, SimpleTest.runTest, self)

    def shortDescription(self):
		"One line description - additionally giving test name"
		parentStr = super(BadDataTest, self).shortDescription()
		return  "%s-%s" % (parentStr, self.__testName)

class ListTest(TestParent):
    """Open and return basic case, but with list input"""

    def __init__(self, samples, expected, secondStageExpected=None, filenameToLookFor=None):
        super(ListTest,self).__init__()
        self.samples = samples
        self.expected = expected
        self.secondStageExpected = secondStageExpected
        self.filenameToLookFor = filenameToLookFor
        self.tfileNames = []

    def fixExpected(self, indx, fname):
        """change the filename slot in self.expected"""
        # expected is a tuple. Need to convert to list and back
        tempList = list(self.expected[indx])
        tempList[0] = fname
        self.expected[indx] = tuple(tempList)

    def runTest(self):
        """ListTest.runTest

        Create temp files with known content, one per list element. Run parser and compare result
        """
        for indx in range(0, len(self.samples)):
            tfileName = self.TempFile(self.samples[indx])
            self.tfileNames.append(tfileName)
            self.fixExpected(indx, tfileName)
        self.expected = self.fixupDirsInExpectedList(self.expected)
        parser = MbcParser(self.tfileNames)
        parser.execute()
        result = parser()
        self.assertEquals(result, self.expected,
                        "Result(%s) not same as Expected(%s)"%(result,self.expected))
        if self.secondStageExpected:
            getFolderList = GetFolderList(result)
            getFolderList.execute()
            folderList = getFolderList()
            self.assertEquals(folderList, self.secondStageExpected,
                       "Result2(%s) not same as Expected2(%s)"%(folderList,self.secondStageExpected))

    def tearDown(self):
        if self.tfileNames:
            for fname in self.tfileNames:
                os.unlink(fname)

class FolderListUnitTest(TestParent):
    """Test GetFolderList with on-the-fly generated data.

    Create a list on fly with folder of one temp file and a non-existant one. Treatement of second
    is optional."""

    def __init__(self, fussyOnNonExist):
        super(FolderListUnitTest,self).__init__()
        self.__fussyOnNonExist = fussyOnNonExist
        self.__tempFile = None

    def shortDescription(self):
		"""One line description - additionally giving option"""
		parentStr = super(FolderListUnitTest, self).shortDescription()
		return  "%s-%s" % (parentStr, str(self.__fussyOnNonExist))

    def __realTest(self):
        "real test run - separate so can be trapped if required"

        self.__tempFile = tempfile.NamedTemporaryFile() # used to create list and check

        (input,tempFileName,expected) = self.__createDataLists()
        getFolderList = GetFolderList(input, nameToCheck=tempFileName)
        getFolderList.execute()
        result = getFolderList()
        self.assertEquals(result, expected,
                "Result2(%s) not same as Expected2(%s)(filename=%s)"%(result,expected,tempFileName))

    def runTest(self):
        "FolderListUnitTest.runTest"
        if not self.__fussyOnNonExist:
            self.__realTest()
        else:
            # should fail
            self.assertRaises(MissingFile, self.__realTest)

    def tearDown(self):
        "Stop using temp file, so will be deleted"
        self.__tempFile = None

    def __createDataLists(self):
        """Create input and output for test run as lists.

        input will be one element with <tempdir> and second with "nonexistant",
        but which element is used depends on fussyOnNonExist"""
        input = []
        tempFileName = None
        expected = []

        (tempDir,tempFileName) = os.path.split(self.__tempFile.name) # the dir and name of the temporary file we are using
        input += [("f1", [tempDir], [], [])] # the existing file
        expected += [(True, tempDir, 'From f1')]
        if self.__fussyOnNonExist:
            input += [("f2", ["nonexistant"], [], [])]
        else:
            input += [("f2", [], ["nonexistant"], [])]
        expected += [(True, None, 'Skip "nonexistant" from f2')] # always return the non-fussy version, as with fussy we expect exception raised

        return (input,tempFileName,expected)

class FolderListIntTest(TestParent):
    """Integration test combining MbcParser and FolderList

    Create a temporary folder. Add the following contents:

    x/bld.inf
    y/bld.inf
    z/bld.inf
    mbc containing "./x, ./y, [optional] ./z"

    z/bld.inf and y.bld are optional
        option="x" no z or y. Should raise exception.
        option="xy" no z but y. Should get list of ../x and ../y
        option="xz" no y but z. Should raise exception.
        option="xyz" both y and z. Should get list of ../x, ../y and ../z

    """

    def __init__(self, option):
        super(FolderListIntTest,self).__init__()
        self.__option = option
        self.__testDir = None
        self.__testDirs = [] # list of dirs we create, so we can delete them
        self.__testFiles = [] # list of files we create, so we can delete them
        self.__fullMbcFileName = None
        self.__expectedResult = []

    def shortDescription(self):
        "One line description - additionally giving option"
        parentStr = super(FolderListIntTest, self).shortDescription()
        return  "%s-%s" % (parentStr, str(self.__option))

    def tearDown(self):
        for fle in self.__testFiles:
            try:
                os.unlink(fle)
            except:
                pass # ignore any error. assume means we didn't create the file in the end
        # delete folders in reverse, so child directories deleted after parent
        for dir in self.__testDirs[len(self.__testDirs)-1::-1]:
            try:
                os.rmdir(dir)
            except:
                pass # ignore any error. assume means we didn't create the file in the end

    def runTest(self):
        "FolderListIntTest.runTest"
        self.__setup()
        if "y" in self.__option:
            self.__realTest()
        else:
            # expected to raise exception as y/bld.inf does not exist
            self.assertRaises(MissingFile, self.__realTest)

    def __realTest(self):
        parser = MbcParser(self.__fullMbcFileName)
        parser.execute()
        folderList = GetFolderList(parser())
        folderList.execute()
        result = folderList()
        self.assertEquals(result, self.__expectedResult,
            "Result (%s) not that expected (%s)" % (str(result), str(self.__expectedResult)))

    def __setup(self):
        self.__testDir = tempfile.mkdtemp() # __testDir is name of temp folder
        self.__testDirs.append(self.__testDir)
        self.__fullMbcFileName = os.path.join(self.__testDir, "test.mbc")

        for name in ["x","y","z"]:
            fullpath = os.path.join(self.__testDir, name)
            if name in self.__option:
                os.mkdir(fullpath)
                self.__testDirs.append(fullpath)
                filepath = os.path.join(fullpath, "bld.inf")
                fileToWrite = file(filepath, "w")
                self.__testFiles.append(filepath)
                print >>fileToWrite, "//generated" # 9.5 syntax
                fileToWrite.close()
                expected = (True, fullpath, "From %s" % self.__fullMbcFileName)
                self.__expectedResult.append(expected)
            else:
                expected = (True, None, """Skip "%s" from %s""" % (fullpath, self.__fullMbcFileName))
                self.__expectedResult.append(expected)
        mbcFile = file(self.__fullMbcFileName, "w")
        self.__testFiles.append(self.__fullMbcFileName)
        print >>mbcFile, testdata.intTestMbcFile
        mbcFile.close()

class ConfigFileUnitTest(unittest.TestCase):
    """ConfigFile UnitTest"""

    def __init__(self, inputData, expected):
        super(ConfigFileUnitTest,self).__init__()
        self.__inputData = inputData
        self.__expected = expected

    def runTest(self):
        """ConfigFileUnitTest.runTest

        Take dummy folder list and generate XML file. Output goes to string. Compare with expected
        """

        outputStream = StringIO.StringIO()
        generator = ConfigFileGenerator(self.__inputData, outputStream)
        generator.write()
        outputString = outputStream.getvalue()
##        print ("output=%s" % str(outputString))
##        print ("expected=%s" % str(self.__expected))
        self.assertEquals(outputString, self.__expected,
                "Generated output (%s) not same as expected (%s)" % (outputString, self.__expected))

def suite():
    """TestSuite"""

    tests = [
        SimpleTest(testdata.import1, testdata.result1),
        ListTest(testdata.import2, testdata.result2),
        BadDataTest(testdata.badImport1, "bad1"),
        BadDataTest(testdata.badImport2, "bad2"),
        FolderListUnitTest(False),
        FolderListUnitTest(True),
        FolderListIntTest("x"),
        FolderListIntTest("xy"),
        FolderListIntTest("xz"),
        FolderListIntTest("xyz"),
        ConfigFileUnitTest(testdata.testFolderList1, testdata.testXmlFile1),
        ]

    return unittest.TestSuite(tests)


if __name__ == "__main__":
    unittest.TextTestRunner(verbosity=2).run(suite())