# 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())