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