# *-* coding: utf-8 *-*

#

# Copyright (c) 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: 

#

import unittest, os, shutil, sys

try:

    from cElementTree import ElementTree, ElementInclude

except ImportError:

    try:    

        from elementtree import ElementTree, ElementInclude

    except ImportError:

        try:

            from xml.etree import cElementTree as ElementTree

        except ImportError:

            from xml.etree import ElementTree

import __init__	

from templatemlplugin import templatemlplugin

from types import NoneType

from testautomation.base_testcase import BaseTestCase

from testautomation.utils import hex_to_bindata

from cone.public import exceptions,plugin,api,utils

from cone.storage import filestorage

from cone.confml import implml

# Hardcoded value of testdata folder that must be under the current working dir

ROOT_PATH = os.path.dirname(os.path.abspath(__file__))

testdata  = os.path.join(ROOT_PATH,'project')

TEMPML_DOC1 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \

          "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

            "<desc>Desc</desc>" \

            "<output file=\"test.txt\" encoding=\"UTF-16\">" \

                "<template extension=\"foo/foobar:MyClass\">ABCDF</template>" \

             "</output>" \

             "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \

          "</templateml>"

TEMPML_DOC2 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \

          "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

            "<desc>Desc</desc>" \

            "<output file=\"test.txt\" encoding=\"UTF-16\">" \

                "<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \

             "</output>" \

             "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \

          "</templateml>"

TEMPML_DOC3 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \

          "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

            "<desc>Desc</desc>" \

            "<output file=\"test.txt\" encoding=\"UTF-16\">" \

                "<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \

             "</output>" \

             "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \

          "</templateml>"

TEMPML_DOC4 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \

          "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\">" \

            "<output file=\"test.txt\" encoding=\"ascii\">" \

                "<template file=\"../../templates/template.xml\"/>" \

             "</output>" \

             "<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \

          "</templateml>"

TEMPML1 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\">" \

          "<ns0:template extension=\"foo/foobar:MyClass\">ABCDF</ns0:template>" \

          "</ns0:output>"

TEMPML2 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

          "<ns0:template extension=\"foo/foobar:MyClass\">" \

          "include AABBCC" \

          "</ns0:template>" \

          "</ns0:output>"

TEMPML3 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

          "<ns0:template extension=\"foo/foobar:MyClass\">" \

          "include AABBCC" \

          "</ns0:template>" \

          "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \

          "</ns0:output>"

TEMPML4 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \

          "<ns0:template file=\"../../templates/template.xml\"/>" \

          "<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \

          "</ns0:output>"

def impl_from_resource(resource_ref, configuration):

    doc_root = plugin.ReaderBase._read_xml_doc_from_resource(resource_ref, configuration)

    readers = { templateml.TemplatemlImplReader.NAMESPACE: templateml.TemplatemlImplReader }

    ns = utils.xml.split_tag_namespace(doc_root.tag)[0]

    if ns in readers:

        return readers[ns].read_impl(resource_ref, configuration, doc_root)

    else:

        return None

class TestTemplatemlPlugin(BaseTestCase):    

    def setUp(self):

        self.curdir = os.getcwd()

        self.output = os.path.join(ROOT_PATH, 'output')

        os.chdir(os.path.join(ROOT_PATH))

    def tearDown(self):

        os.chdir(self.curdir)

    def load_config(self, config):

        fs = filestorage.FileStorage(testdata)

        p = api.Project(fs)

        return p.get_configuration(config)

    def load_impl(self, resource_ref, config='root1.confml'):

        configuration = self.load_config(config)

        pattern = '^' + resource_ref.replace('.', r'\.') + '$'

        impls = plugin.get_impl_set(configuration, pattern)

        impls.output = self.output

        impl_list = impls.get_implementations_by_file(resource_ref)

        self.assertEquals(1, len(impl_list))

        return impl_list[0]

    def test_parse_desc(self):

        impl = self.load_impl('Layer1/implml/file1.templateml')

        self.assertEqual("Description field text", impl.reader.desc)

    def test_parse_output_with_file_ref(self):

        impl = self.load_impl('Layer1/implml/output_with_ref.templateml')

        self.assertEquals(impl.list_output_files(), [os.path.normpath('output/confmlref_filename.txt')])

    def test_parse_outputs(self):

        impl = self.load_impl('Layer1/implml/file1.templateml')

        outputs = []

        output1 = templatemlplugin.OutputFile()

        output1.set_encoding("UTF-16")

        output1.set_filename("test.txt")

        output1.set_path('')

        temp1 = templatemlplugin.TempFile()

        temp1.set_template(u'ABC kissa k\xe4velee')

        output1.set_template(temp1)

        outputs.append(output1)

        output2 = templatemlplugin.OutputFile()

        output2.set_encoding("UTF-16")

        output2.set_filename("test2.txt")

        output2.set_path("output")

        temp2 = templatemlplugin.TempFile()

        temp2.set_template('AABBCC')

        output2.set_template(temp2)

        outputs.append(output2)

        output3 = templatemlplugin.OutputFile()

        output3.set_encoding("UTF-8")

        output3.set_filename("test3.txt")

        output3.set_path('')

        temp3 = templatemlplugin.TempFile()

        temp3.set_template(u'ABC kissa k\xe4velee')

        output3.set_template(temp3)

        outputs.append(output3)

        self.assertNotEqual(impl.reader.outputs, None)

        self.assertEqual(outputs[0].encoding, impl.reader.outputs[0].encoding)

        self.assertEqual(outputs[0].filename, impl.reader.outputs[0].filename)

        self.assertEqual(outputs[0].path, impl.reader.outputs[0].path)

        self.assertEqual(outputs[0].template.template, impl.reader.outputs[0].template.template)

        self.assertEqual(outputs[0].template.extensions, impl.reader.outputs[0].template.extensions)

        self.assertEqual(outputs[0].template.filters, impl.reader.outputs[0].template.filters)

        self.assertEqual(outputs[0].template, impl.reader.outputs[0].template)

        self.assertEqual(outputs[0], impl.reader.outputs[0])

        self.assertEqual(outputs[1].encoding, impl.reader.outputs[1].encoding)

        self.assertEqual(outputs[1].filename, impl.reader.outputs[1].filename)

        self.assertEqual(outputs[1].path, impl.reader.outputs[1].path)

        #self.assertEqual(outputs[1].template.template, impl.reader.outputs[1].template.template)

        self.assertEqual(outputs[1].template.extensions, impl.reader.outputs[1].template.extensions)

        self.assertEqual(outputs[1].template.filters, impl.reader.outputs[1].template.filters)

        #self.assertEqual(outputs[1].template, impl.reader.outputs[1].template)

        #self.assertEqual(outputs[1], impl.reader.outputs[1])

        self.assertEqual(outputs[2].encoding, impl.reader.outputs[2].encoding)

        self.assertEqual(outputs[2].filename, impl.reader.outputs[2].filename)

        self.assertEqual(outputs[2].path, impl.reader.outputs[2].path)

        #self.assertEqual(outputs[2].template.template, impl.reader.outputs[2].template.template)

        self.assertEqual(outputs[2].template.extensions, impl.reader.outputs[2].template.extensions)

        self.assertEqual(outputs[2].template.filters, impl.reader.outputs[2].template.filters)

        #self.assertEqual(outputs[2].template, impl.reader.outputs[2].template)

        #self.assertEqual(outputs[2], impl.reader.outputs[2])

    def test_parse_outputfile(self):

        output1 = templatemlplugin.OutputFile()

        output2 = templatemlplugin.OutputFile()

        self.assertEqual(output1, output2)

        self.assertEqual(output1.encoding, output2.encoding)

        self.assertEqual(output1.path, output2.path)

        self.assertEqual(output1.filename, output2.filename)

        output1.set_encoding("utf-8")

        output2.set_encoding("utf-8")

        self.assertEqual(output1, output2)# utf-8, utf-8

        output1.set_encoding("utf-16")

        self.assertNotEqual(output1, output2)#utf-16, utf-8

        output2.set_encoding("utf-16")

        self.assertEqual(output1, output2)#utf-16, utf-16

    def test_parse_template(self):

        reader = templatemlplugin.TemplatemlImplReader()

        reader.fromstring(TEMPML_DOC1)

        temp1 = reader.parse_template(ElementTree.fromstring(TEMPML1))

        temp2 = templatemlplugin.TempFile()

        temp2.set_template("ABCDF")

        self.assertEqual(temp1.template, temp2.template)

        self.assertEqual(temp1.extensions, temp2.extensions)

        self.assertEqual(temp1.filters, temp2.filters)

        self.assertEqual(temp1, temp2)

    def test_parse_template_from_xinclude(self):

        try:

            reader = templatemlplugin.TemplatemlImplReader()

            reader.fromstring(TEMPML_DOC2)

            temp1 = reader.parse_template(ElementTree.fromstring(TEMPML2))

            temp2 = templatemlplugin.TempFile()

            temp2.set_template("include AABBCC")

        except exceptions.ParseError, e:

            self.fail("Known bug: ticket #2007")

        self.assertEqual(temp1.template, temp2.template)

        self.assertEqual(temp1.extensions, temp2.extensions)

        self.assertEqual(temp1.filters, temp2.filters)

        self.assertEqual(temp1, temp2)

    def test_parse_template_filter(self):

        try:

            reader = templatemlplugin.TemplatemlImplReader()

            reader.fromstring(TEMPML_DOC3)

            filters1 = reader.filters

            filter2 = templatemlplugin.Filter()

            filter2.set_code("lambda a,b: a+b")

            filter2.set_name("test_filter")

        except exceptions.ParseError, e:

            self.fail( "Known bug: ticket #2007")

        self.assertEqual(filters1[0].name, filter2.name)

        self.assertEqual(filters1[0].code, filter2.code)

        self.assertEqual(filters1[0], filter2)

    def test_parse_template_filter(self):

        class DummyConfiguration(object):

            def get_resource(self, ref):

                class DummyResource(object):

                    def read(self): return ''

                    def close(self): return None

                return DummyResource()

            def get_default_view(self): return None

        reader = templatemlplugin.TemplatemlImplReader('foo/implml/bar.implml', DummyConfiguration())

        reader.fromstring(TEMPML_DOC4)

        filters1 = reader.filters

        filter2 = templatemlplugin.Filter()

        filter2.set_code(None)

        filter2.set_name("test_filter")

        filter2.set_path("../../filter/filter.py")

        temp1 = reader.parse_template(ElementTree.fromstring(TEMPML4))

        temp2 = templatemlplugin.TempFile()

        temp2.set_template('')

        temp2.set_path('')

        self.assertEqual(filters1[0].name, filter2.name)

        self.assertEqual(filters1[0].code, filter2.code)

        self.assertEqual(filters1[0].path, filter2.path)

        self.assertEqual(filters1[0], filter2)

        self.assertEqual(temp1.template, temp2.template)

        self.assertEqual(temp1.extensions, temp2.extensions)

        self.assertEqual(temp1.filters, temp2.filters)

        self.assertEqual(temp1, temp2)

    def test_simple_generate_prj(self):

        self.remove_if_exists(os.path.normpath("output/output/test.txt"))

        impl = self.load_impl('Layer1/implml/file2.templateml')

        #impl.context = {'name' : 'some value'}

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test.txt")))

        result_file = None

        try:

            result_file = open(os.path.normpath("output/output/test.txt"))

            for line in result_file:

                self.assertTrue(line == "include AABBCC")

        finally:

            if result_file != None: result_file.close()

    def test_simple_generate_prj3(self):

        self.remove_if_exists(os.path.normpath("output/output/test3.txt"))

        impl = self.load_impl('Layer1/implml/file3.templateml')

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test3.txt")))

        result_file = None

        try:

            result_file = open(os.path.normpath("output/output/test3.txt"))

            for line in result_file:

                self.assertTrue(line == "'Hello John Doe!'")

        finally:

            if result_file != None: result_file.close()

    def test_simple_generate_prj4_with_filters(self):

        self.remove_if_exists(os.path.normpath("output/output/test4a.txt"))

        self.remove_if_exists(os.path.normpath("output/output/test4b.txt"))

        self.remove_if_exists(os.path.normpath("output/output/test4c.txt"))

        self.remove_if_exists(os.path.normpath("output/output/test4d.txt"))

        impl = self.load_impl('Layer1/implml/file4.templateml')

        #impl.context = {'name' : 'John Doe'}

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test4a.txt")))

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test4b.txt")))

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test4c.txt")))

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test4d.txt")))

        result_file1 = None

        result_file2 = None

        result_file3 = None

        result_file4 = None

        try:

            result_file1 = open(os.path.normpath("output/output/test4a.txt"))

            result_file2 = open(os.path.normpath("output/output/test4b.txt"))

            result_file3 = open(os.path.normpath("output/output/test4c.txt"))

            result_file4 = open(os.path.normpath("output/output/test4d.txt"))

            if result_file1 != None: 

                for line in result_file1:

                    self.assertTrue(line == "'Hello John Doe!'")

            else:

                self.fail("No result file found: output/output/test4a.txt")

            if result_file2 != None: 

                for line in result_file2:

                    self.assertTrue(line == "'Hello John Doe again!'")

            else:

                self.fail("No result file found: output/output/test4b.txt")

            if result_file3 != None:

                for line in result_file3:

                    self.assertTrue(line == "2+3=5")

            else:

                self.fail("No result file found: output/output/test4c.txt")

            if result_file4 != None:

                for line in result_file4:

                    self.assertTrue(line == "--6")

            else:

                self.fail("No result file found: output/output/test4d.txt")

        finally:

            if result_file1 != None: result_file1.close()

            if result_file2 != None: result_file2.close()

            if result_file3 != None: result_file3.close()

            if result_file4 != None: result_file4.close()

    def test_simple_generate_prj_extfiles_with_filters(self):

        self.remove_if_exists(os.path.normpath("output/output/test_ext_temp_file.txt"))

        impl = self.load_impl('Layer1/implml/external_tempfile.templateml')

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test_ext_temp_file.txt")))

        result_file1 = None

        try:

            result_file1 = open(os.path.normpath("output/output/test_ext_temp_file.txt"))

            lines = 0

            if result_file1 != None: 

                for line in result_file1:

                    self.assertTrue(line == "2+3=-1")

                    lines += 1

            else:

                self.fail("No result file found: output/output/test_ext_temp_file.txt")

            self.assertTrue(lines == 1, "Wrong number of lines generated.")

        finally:

            if result_file1 != None: result_file1.close()

    def test_generate_prj1(self):

        self.remove_if_exists(os.path.normpath("output/output/test5a.txt"))

        impl = self.load_impl('Layer1/implml/file5.templateml')

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/output/test5a.txt")))

        result_file1 = None

        try:

            result_file1 = open(os.path.normpath("output/output/test5a.txt"))

            if result_file1 != None: 

                for line in result_file1:

                    self.assertTrue(line == "'Hello John Doe'")

            else:

                self.fail("No result file found: output/output/test5a.txt")

        finally:

            if result_file1 != None: result_file1.close()

    def test_generate_access_configuration(self):

        self.remove_if_exists(os.path.normpath("output/access_configuration.txt"))

        impl = self.load_impl('Layer1/implml/access_configuration.templateml')

        impl.generate()

        self.assertTrue(os.path.exists(os.path.normpath("output/access_configuration.txt")))

        result_file1 = None

        try:

            result_file1 = open(os.path.normpath("output/access_configuration.txt"))

            data = result_file1.read() 

            if result_file1 != None: 

                self.assertTrue(data.startswith("Configuration name: root1.confml"))

            else:

                self.fail("No result file found: output/access_configuration.txt")

        finally:

            if result_file1 != None: result_file1.close()

    def test_create_context_dict1(self):

        impl = self.load_impl('Layer1/implml/file6.templateml')

        impl.context = impl.create_dict()

        impl.generate()

    def test_list_output_files(self):

        impl = self.load_impl('Layer1/implml/file1.templateml')

        impl.set_output_root('outdir')

        output_files = impl.list_output_files()

        expected = map(lambda n: os.path.normpath(n), [

            'outdir/test.txt',

            'outdir/output/test2.txt',

            'outdir/test3.txt',

            'outdir/output/test4.txt',

            'outdir/some/test/path/test5.txt',

        ])

        self.assertEquals(sorted(output_files), sorted(expected))

    def test_has_ref(self):

        impl = self.load_impl('Layer1/implml/has_ref_template_test2.templateml')

        self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)

        self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)

        self.assertEquals(impl.has_ref('Feature2'), True)

        self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)

        self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)

        self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)

    def test_has_ref_external_template(self):

        impl = self.load_impl('Layer1/implml/has_ref_template_test3.templateml')

        self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)

        self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)

        self.assertEquals(impl.has_ref('Feature2'), True)

        self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)

        self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)

        self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)

    def test_has_ref_with_featree(self):

        impl = self.load_impl('Layer1/implml/has_ref_template_test.templateml')

        self.assertEquals(impl.has_ref('Feature1.StringSetting'), True)

        self.assertEquals(impl.has_ref('Feature2.StringSetting'), True)

    def test_unicode_in_template_and_value(self):

        OUTPUT_DIR = os.path.join(ROOT_PATH, 'output', 'unicode_test')

        self.remove_if_exists(OUTPUT_DIR)

        fs = filestorage.FileStorage(testdata)

        p = api.Project(fs)

        config = p.get_configuration('root1.confml')

        impls = plugin.get_impl_set(config,'unicode_template_test\.templateml$')

        impls.output = OUTPUT_DIR

        impls.generate()

        self.assert_exists_and_contains_something(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"))

        # Check that the output exists and contains expected lines

        f = open(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"), "rb")

        try:        data = f.read().decode('utf-8')

        finally:    f.close()

        self.assertTrue(data.find(u'Value of Feature1.UnicodeValueSetting: カタカナ') != -1)

        self.assertTrue(data.find(u'Unicode from template: ελληνικά') != -1)

    def test_create_context_dict_and_list(self):

        config = self.load_config('create_dict_test.confml')

        impls = plugin.get_impl_set(config, r'^create_dict_test/implml/test\.templateml$')

        self.assertEquals(1, len(impls))

        impl = iter(impls).next()

        context = impl.create_dict()

        feat_tree = context['feat_tree']

        feat_list = context['feat_list']

        self.assertEqual(context['configuration'], config)

        # Check the created dictionary

        expected_tree_file = os.path.join(ROOT_PATH, 'create_dict_test', 'expected_tree.txt')

        expected_tree = eval(self.read_data_from_file(expected_tree_file).replace('\r', ''))

        if feat_tree != expected_tree: