#

# 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

import os

import logging

import __init__

from cone.public import *

from cone.public import _plugin_reader

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

Tfd = _plugin_reader.TempVariableDefinition

Tsfd = _plugin_reader.TempVariableSequenceDefinition

Sro = _plugin_reader.SettingRefsOverride

MULTI_IMPL_1 = """<?xml version="1.0" encoding="UTF-8"?>

<common:container xmlns:common="http://www.symbianfoundation.org/xml/implml/1">

    <impl xmlns="http://www.test.com/xml/1">

        <elem x="1" y="2"/>

    </impl>

    <impl xmlns="http://www.test.com/xml/2">

        <dummy z="500"/>

        <elem x="10" y="20"/>

    </impl>

    <impl xmlns="http://www.test.com/xml/3">

        <elem x="100" y="200"/>

        <elem z="300"/>

    </impl>

</common:container>

""".encode('utf-8')

MULTI_IMPL_2 = """<?xml version="1.0" encoding="UTF-8"?>

<container xmlns="http://www.symbianfoundation.org/xml/implml/1"

    xmlns:ns0="http://www.test.com/xml/1" 

    xmlns:ns2="http://www.test.com/xml/2"

    xmlns:ns3="http://www.test.com/xml/3">

    <ns0:impl>

      <ns0:elem x="1" y="2"/>

    </ns0:impl>

    <ns2:impl>

      <ns2:dummy z="500"/>

      <ns2:elem x="10" y="20"/>

    </ns2:impl>

    <ns3:impl>

      <ns3:elem x="100" y="200"/>

      <ns3:elem z="300"/>

    </ns3:impl>

</container>

""".encode('utf-8')

MULTI_IMPL_3 = """<?xml version="1.0" encoding="UTF-8"?>

<container xmlns="http://www.symbianfoundation.org/xml/implml/1">

    <impl1:impl xmlns:impl1="http://www.test.com/xml/1">

        <impl1:elem x="1" y="2"/>

    </impl1:impl>

    <impl2:impl xmlns:impl2="http://www.test.com/xml/2">

        <impl2:elem x="1" y="2"/>

    </impl2:impl>

    <impl1:impl xmlns:impl1="http://www.test.com/xml/1">

        <impl1:elem a="1" b="2"/>

    </impl1:impl>

    <impl2:impl xmlns:impl2="http://www.test.com/xml/2">

        <impl2:elem a="1" b="2"/>

    </impl2:impl>

</container>

""".encode('utf-8')

UNSUPPORTED_IMPL_1 = """<?xml version="1.0" encoding="UTF-8"?>

<test_impl>

    <impl xmlns="http://www.test.com/xml/1">

        <elem x="1" y="2"/>

    </impl>

    <impl xmlns="http://www.test.com/xml/2">

        <dummy z="500"/>

        <elem x="10" y="20"/>

    </impl>

    <impl xmlns="http://www.test.com/xml/4">

        <elem x="1" y="2"/>

    </impl>

</test_impl>

""".encode('utf-8')

UNSUPPORTED_IMPL_2 = """<?xml version="1.0" encoding="UTF-8"?>

<test_impl xmlns="http://www.test.com/xml/6"

    xmlns:ns2="http://www.test.com/xml/2"

    xmlns:ns4="http://www.test.com/xml/4">

    <elem x="1" y="2"/>

    <ns2:dummy z="500"/>

    <ns2:elem x="10" y="20"/>

    <ns4:elem x="1" y="2"/>

</test_impl>

""".encode('utf-8')

SINGLE_IMPL_1 = """<?xml version="1.0" encoding="UTF-8"?>

<impl xmlns="http://www.test.com/xml/1">

    <elem x="1"/>

    <elem y="2"/>

    <elem z="3"/>

</impl>

""".encode('utf-8')

SINGLE_IMPL_2 = """<?xml version="1.0" encoding="UTF-8"?>

<joujou xmlns="http://www.test.com/xml/2"/>

""".encode('utf-8')

SINGLE_IMPL_3 = """<?xml version="1.0" encoding="UTF-8"?>

<impl xmlns="http://www.test.com/xml/3">

    <elem x="1"/>

</impl>

""".encode('utf-8')

IGNORED_NAMESPACE_IMPL_1 = """<?xml version="1.0" encoding="UTF-8"?>

<common:container xmlns:common="http://www.symbianfoundation.org/xml/implml/1">

    <impl xmlns="http://www.test.com/xml/3">

        <elem x="1"/>

    </impl>

    <ignored xmlns:ignored="http://www.test.com/xml/ignored/3">

        <elem test="foo"/>

    </ignored>

</common:container>

""".encode('utf-8')

IGNORED_NAMESPACE_IMPL_2 = """<?xml version="1.0" encoding="UTF-8"?>

<impl xmlns="http://www.test.com/xml/3" xmlns:ignored="http://www.test.com/xml/ignored/3">

    <elem x="1"/>

    <ignored:some_elem/>

</impl>

""".encode('utf-8')

NO_IMPL = """<?xml version="1.0" encoding="UTF-8"?>

<impl>

</impl>

""".encode('utf-8')

class Mock(object):

    pass

class MockView(object):

    def __init__(self, feature_dict):

        self.feature_dict = feature_dict

    def get_feature(self, ref):

        feature = Mock()

        feature.get_value = lambda: self.feature_dict[ref]

        feature.get_original_value = lambda: self.feature_dict[ref]

        return feature

class MockConfiguration(object):

    def __init__(self, resources, features={}):

        self.resources = resources

        self.features = features

    def get_resource(self, ref):

        res = Mock()

        res.read = lambda: self.resources[ref]

        res.close = lambda: None

        return res

    def get_layer(self):

        layer = Mock()

        layer.list_implml = lambda: self.resources.keys()

        return layer

    def get_doc(self, ref):

        return utils.etree.fromstring(self.get_resource(ref).read())

    def get_default_view(self):

        return MockView(self.features)

class MockImpl(plugin.ImplBase):

    def __init__(self, data):

        self.data = data

        self.generate_invoked = False

    @classmethod

    def create(cls, resource_ref, configuration, data):

        impl = cls(data)

        plugin.ImplBase.__init__(impl, resource_ref, configuration)

        return impl

    def generate(self, context=None):

        if context and hasattr(context,'objects'):

            context.objects.append(self) 

        self.generate_invoked = True

    def __repr__(self):

        return "MockImpl(%r)" % self.data

    def __eq__(self, other):

        if type(self) == type(other):

            return self.data == other.data

        else:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __lt__(self, other):

        if type(self) == type(other):

            return self.data < other.data

        else:

            return False

class MockReaderBase(plugin.ReaderBase):

    @classmethod

    def read_impl(cls, resource_ref, configuration, root_elem):

        data = [cls.__name__, resource_ref]

        for elem in root_elem.findall('{%s}elem' % cls.NAMESPACE):

            data.append(elem.attrib)

        return MockImpl.create(resource_ref, configuration, data)

class MockReader1(MockReaderBase):

    NAMESPACE = "http://www.test.com/xml/1"

    FILE_EXTENSIONS = ['mock1ml']

class MockReader2(MockReaderBase):

    NAMESPACE = "http://www.test.com/xml/2"

    FILE_EXTENSIONS = ['mock2ml']

class MockReader3(MockReaderBase):

    NAMESPACE = "http://www.test.com/xml/3"

    IGNORED_NAMESPACES = ["http://www.test.com/xml/ignored/3"]

    FILE_EXTENSIONS = ['mock3ml', 'test3ml']

MOCK_READER_CLASSES = [MockReader1, MockReader2, MockReader3]

mock_config = MockConfiguration({

    'layer1/implml/multi1.implml'           : MULTI_IMPL_1,

    'layer1/implml/multi2.implml'           : MULTI_IMPL_2,

    'layer1/implml/multi3.implml'           : MULTI_IMPL_3,

    'layer1/implml/unsupported1.implml'     : UNSUPPORTED_IMPL_1,

    'layer1/implml/unsupported2.implml'     : UNSUPPORTED_IMPL_2,

    'layer1/implml/single1.implml'          : SINGLE_IMPL_1,

    'layer1/implml/single2.implml'          : SINGLE_IMPL_2,

    'layer1/implml/single3.implml'          : SINGLE_IMPL_3,

    'layer1/implml/none.implml'             : NO_IMPL,

    'layer1/implml/broken.implml'           : 'Some invalid XML data...',

    'layer1/implml/single1.mock1ml'         : SINGLE_IMPL_1,

    'layer1/implml/single2.mock2ml'         : SINGLE_IMPL_2,

    'layer1/implml/single3.mock3ml'         : SINGLE_IMPL_3,

    'layer1/implml/single3.test3ml'         : SINGLE_IMPL_3,

    'layer1/implml/ignored_ns_1.mock3ml'    : IGNORED_NAMESPACE_IMPL_1,

    'layer1/implml/ignored_ns_2.mock3ml'    : IGNORED_NAMESPACE_IMPL_2,

    'layer1/implml/multi1.dummyml'          : MULTI_IMPL_1,

    'layer1/implml/dummy'                   : MULTI_IMPL_1,

})

class TestPluginImplBase(unittest.TestCase):

    def setUp(self):

        pass

    def test_implbase_add_tags(self):

        impl = plugin.ImplBase('test',None)

        impl.set_tags({'target': ['test', 'foo']})

        self.assertEquals(impl.get_tags()['target'],['test','foo'])

        #self.assertEquals(impl.has_tag({}, policy='OR'), True)

        self.assertEquals(impl.has_tag({'target': ['test']}, policy='OR'), True)

        self.assertEquals(impl.has_tag({'target': ['test']}, policy='AND'), True)

        self.assertEquals(impl.has_tag({'target': ['foo']}, policy='OR'), True)

        self.assertEquals(impl.has_tag({'target': ['foo']}, policy='AND'), True)

        self.assertEquals(impl.has_tag({'target': ['test','foo']}, policy='OR'), True)

        self.assertEquals(impl.has_tag({'target': ['test','foo']}, policy='AND'), True)

        self.assertEquals(impl.has_tag({'target': ['test2','foo']}, policy='OR'), True)

        self.assertEquals(impl.has_tag({'target': ['test2','foo']}, policy='AND'), False)

        self.assertEquals(impl.has_tag({'foo': ['foo']}, policy='OR'), False)

        self.assertEquals(impl.has_tag({'foo': ['foo']}, policy='AND'), False)

        self.assertEquals(impl.has_tag({'target': ['foo'], 'foo':['bar']}, policy='AND'), False)

        self.assertEquals(impl.has_tag({'target': ['foo'], 'foo':['bar']}, policy='OR'), True)

    def test_implbase_tags_with_refs(self):

        config = MockConfiguration({}, features = {

            'Foo.Bar'           : 'foobar',

            'Foo.Baz'           : 'foobaz',

            'Feature.TagName'   : 'tagname',

            'Feature.TagValue'  : 'tagvalue',

        })

        impl = plugin.ImplBase('test', config)

        impl.set_tags({

            'test'              : ['${Foo.Bar}', 'foo', 'bar', '${Foo.Bar} and ${Foo.Baz}'],

            '${Feature.TagName}': ['${Feature.TagValue}']})

        expected = {

            'test': ['foobar', 'foo', 'bar', 'foobar and foobaz'],

            'tagname': ['tagvalue'],

        }

        self.assertEquals(impl.get_tags(), expected)

    def test_has_ref(self):

        impl = plugin.ImplBase('test', None)

        self.assertEquals(impl.has_ref('Foo.Bar'), None)

        impl.get_refs = lambda: ['Foo.Bar', 'Xyz']

        # Test using different supported parameter types

        self.assertTrue(impl.has_ref('Foo.Bar'))

        self.assertTrue(impl.has_ref(['Foo.Bar']))

        self.assertTrue(impl.has_ref(('Foo.Bar',)))

        # Impl uses the exact given ref

        self.assertTrue(impl.has_ref('Foo.Bar'))

        self.assertTrue(impl.has_ref('Xyz'))

        # Impl uses the given ref's parent ref

        self.assertTrue(impl.has_ref('Foo.Bar.Baz'))

        self.assertTrue(impl.has_ref('Xyz.Zyx'))

        # Impl does not use the entire parent ref of 'Foo.Bar', only the

        # 'Bar' sub-ref

        self.assertFalse(impl.has_ref('Foo'))

        # Various refs almost matching a specified ref

        self.assertFalse(impl.has_ref('Fo'))

        self.assertFalse(impl.has_ref('Fog'))

        self.assertFalse(impl.has_ref('Food'))

        self.assertFalse(impl.has_ref('Foo.Ba'))

        self.assertFalse(impl.has_ref('Foo.Bag'))

        self.assertFalse(impl.has_ref('Foo.Bard'))

        # Various refs not at all in the impl's ref list

        self.assertFalse(impl.has_ref('Yay'))

        self.assertFalse(impl.has_ref(['Yay', 'Fhtagn']))

        # One of the refs in the given list matches

        self.assertTrue(impl.has_ref(['Yay', 'Fhtagn', 'Foo.Bar']))

        self.assertTrue(impl.has_ref(['Yay', 'Foo.Bar.Baz', 'Fhtagn']))

        self.assertTrue(impl.has_ref(['Yay', 'Xyz', 'Fhtagn']))

    def test_impl_container_eval_context_with_tags(self):

        container = plugin.ImplBase("norm", None)

        context = plugin.GenerationContext()

        self.assertTrue(container._eval_context(context))

        container.set_tags({'target':['rofs2','core']})

        context.tags = {'target': ['rofs2'], 'foobar': ['test']}

        self.assertTrue(container._eval_context(context))

        context.tags_policy = "AND"

        self.assertFalse(container._eval_context(context))

        container.set_tags({})

        self.assertFalse(container._eval_context(context))

        context.tags = {'target': ['rofs2']}

        self.assertFalse(container._eval_context(context))

        context.tags = {}

        self.assertTrue(container._eval_context(context))

class TestPluginImplSet(unittest.TestCase):

    def test_add_implementation_and_list(self):

        container = plugin.ImplSet()

        imp1  = plugin.ImplBase("implml/test.content",None)

        imp2a = plugin.ImplBase("implml/copy.content",None)

        imp2b = plugin.ImplBase("implml/copy.content",None)

        container.add_implementation(imp1)

        container.add_implementation(imp2a)

        container.add_implementation(imp2b)

        self.assertEquals(sorted(container.list_implementation()),

                          sorted(['implml/test.content',

                                  'implml/copy.content']))

    def test_add_implementation_and_get_implementations_by_file(self):

        container = plugin.ImplSet()

        imp1  = plugin.ImplBase("implml/test.content",None)

        imp2a = plugin.ImplBase("implml/copy.content",None)

        imp2b = plugin.ImplBase("implml/copy.content",None)

        container.add_implementation(imp1)

        container.add_implementation(imp2a)

        container.add_implementation(imp2b)

        self.assertEquals(container.get_implementations_by_file("implml/test.content"), [imp1])

        self.assertEquals(sorted(container.get_implementations_by_file("implml/copy.content")),

                          sorted([imp2a, imp2b]))

    def test_add_implementation_and_remove_implementation(self):

        container = plugin.ImplSet()

        imp1  = plugin.ImplBase("implml/test.content",None)

        imp2a = plugin.ImplBase("implml/copy.content",None)

        imp2b = plugin.ImplBase("implml/copy.content",None)

        container.add_implementation(imp1)

        container.add_implementation(imp2a)

        container.add_implementation(imp2b)

        container.remove_implementation("implml/test.content")

        self.assertEquals(len(container.list_implementation()),1)

        self.assertEquals(container.list_implementation()[0],"implml/copy.content")

    def test_add_implementation_and_remove_all(self):

        container = plugin.ImplSet()

        imp1  = plugin.ImplBase("implml/test.content",None)

        imp2a = plugin.ImplBase("implml/copy.content",None)

        imp2b = plugin.ImplBase("implml/copy.content",None)

        imp3  = plugin.ImplBase("implml/foo.content",None)

        container.add_implementation(imp1)

        container.add_implementation(imp2a)

        container.add_implementation(imp2b)

        container.add_implementation(imp3)

        for implref in container.list_implementation():

            container.remove_implementation(implref)

        self.assertEquals(len(container.list_implementation()),0)

    def test_create_impl_set(self):

        plugin.create_impl_set('',None);

        pass

    def test_add_implementation_find_with_tags(self):

        class TestPlugin(plugin.ImplBase):

            pass

        container = plugin.ImplSet()

        imp1 = TestPlugin("implml/test.content",None)

        imp2 = TestPlugin("implml/copy.content",None)

        imp3 = TestPlugin("implml/foo.content",None)

        imp1.set_tags({'target': ['core','rofs2','rofs3']})

        imp2.set_tags({'target': ['rofs3','uda']})

        imp3.set_tags({'target': ['mmc','uda']})

        container.add_implementation(imp1)

        container.add_implementation(imp2)

        container.add_implementation(imp3)

        self.assertEquals(list(container.filter_implementations(tags={'target' : ['rofs3']})),

                          [imp1,imp2])

        self.assertEquals(list(container.filter_implementations(tags={'target' : ['uda']})),

                          [imp2,imp3])

        self.assertEquals(list(container.filter_implementations(tags={'target' : ['mmc','uda']}, policy='AND')),

                          [imp3])

        self.assertEquals(list(container.filter_implementations(tags={'target' : ['mmc','uda']}, policy='OR')),

                          [imp2, imp3])

        cont = container.filter_implementations(tags={'target' : ['core']}) | container.filter_implementations(tags={'target' : ['mmc']}) 

        self.assertEquals(len(cont),2)

        self.assertEquals(list(cont), [imp1,imp3])

        cont = container.filter_implementations(tags={'target' : ['rofs3']}) & container.filter_implementations(tags={'target' : ['uda']}) 

        self.assertEquals(len(cont),1)

        self.assertEquals(list(cont), [imp2])

    def test_pre_impl_filter(self):

        resources = [

            "foo.txt",

            ".hidden_file",

            ".test/test.txt",

            "layer1/implml/.hidden",

            "layer1/implml/test.crml",

            "layer1/implml/test3.gcfml",

            "layer1/implml/.svn/text-base/test.crml.svn-base",

            "layer1/implml/subdir/test5.crml",

            "layer1/implml/subdir/test6.ruleml",

            "layer1/implml/subdir/.scripts/test6_ruleml.py",

        ]

        expected = [

            "foo.txt",

            "layer1/implml/test.crml",

            "layer1/implml/test3.gcfml",

            "layer1/implml/subdir/test5.crml",

            "layer1/implml/subdir/test6.ruleml",

        ]

        self.assertEquals(expected, plugin.pre_filter_impls(resources))

        # Test with backslashes

        resources = map(lambda path: path.replace('/', '\\'), resources)

        expected = map(lambda path: path.replace('/', '\\'), expected)

        self.assertEquals(expected, plugin.pre_filter_impls(resources))

class TestPluginImplSetCopy(unittest.TestCase):

    class TestImpl(plugin.ImplBase):

        pass # No default invocation phase specified, should be 'normal'

    class PreImpl(plugin.ImplBase):

        DEFAULT_INVOCATION_PHASE = 'pre'

    class NormalImpl(plugin.ImplBase):

        DEFAULT_INVOCATION_PHASE = 'normal'

    class PostImpl(plugin.ImplBase):

        DEFAULT_INVOCATION_PHASE = 'post'

    def setUp(self):

        plugin.ImplFactory.set_reader_classes_override(MOCK_READER_CLASSES)

    def tearDown(self):

        plugin.ImplFactory.set_reader_classes_override(None)

    def _get_impl_container(self):

        impl_files = ['layer1/implml/single1.implml',

                      'layer1/implml/single2.implml',

                      'layer1/implml/single3.implml',

                      'layer1/implml/multi1.implml',

                      'layer1/implml/multi2.implml']

        return plugin.create_impl_set(impl_files, mock_config)

    def test_get_test_impl_container(self):

        container = self._get_impl_container()

        # There are 5 ImplML files

        self.assertEquals(len(container.list_implementation()), 5)

        # ...but two of them contain 3 implementations each

        self.assertEquals(len(container), 5)

    def _get_phase_test_impl_container(self):

        return plugin.ImplSet([

            self.TestImpl('foo.test', None),

            self.NormalImpl('foo.norm', None),

            self.PreImpl('foo.pre', None),

            self.PostImpl('test.post', None),

            self.PostImpl('foo.post', None),

        ])

    def test_get_phase_test_impl_container(self):