##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Basic Page Template tests

$Id$
"""
from elementtree import ElementTree as ET
import unittest
import tempfile
import re
from StringIO import StringIO

from zope.publisher.interfaces.browser import IBrowserRequest
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from zope.interface import implements
from zope.interface import Interface

def check_html(s1, s2):
    s1 = normalize_html(s1)
    s2 = normalize_html(s2)
    assert s1==s2, (s1, s2, "HTML Output Changed")

def check_xml(s1, s2):
    s1 = normalize_xml(s1)
    s2 = normalize_xml(s2)
    assert s1==s2, ("XML Output Changed:\n%r\n\n%r" % (s1, s2))

def normalize_html(s):
    s = re.sub(r"[ \t]+", " ", s)
    s = re.sub(r"/>", ">", s)
    return s

def normalize_xml(s):
    s = re.sub(r"\s+", " ", s)
    s = re.sub(r"(?s)\s+<", "<", s)
    s = re.sub(r"(?s)>\s+", ">", s)
    return s

class MeldTemplateFileTests(unittest.TestCase):
    def _getTargetClass(self):
        import meldtemplatefile
        return meldtemplatefile.MeldTemplateFile

    def _makeOne(self, *arg, **kw):
        return self._getTargetClass()(*arg, **kw)
    
    def test_ctor_defaults(self):
        ob = self._makeOne('input/sample.html')
        self.assertEqual(ob.filename, 'input/sample.html')
        self.assertEqual(ob.content_type, 'text/html')

    def test_ctor_with_string_prefix(self):
        self.assertRaises(ValueError,
                          self._makeOne, 'input/sample.html', 'bogus')

    def test_ctor_with_globals_prefix(self):
        ob = self._makeOne('input/sample.html', globals())
        self.assertEqual(ob.filename, 'input/sample.html')
        self.assertEqual(ob.content_type, 'text/html')

    def test_ctor_with_content_type(self):
        ob = self._makeOne('input/sample.html', content_type='text/xml')
        self.assertEqual(ob.filename, 'input/sample.html')
        self.assertEqual(ob.content_type, 'text/xml')
        
    def test_read_html_file(self):
        ob = self._makeOne('input/sample.html')
        text, type_, encoding, mode = ob.read_file()
        expected = open('input/sample.html', 'r').read()
        from meldtemplatefile import meta_pattern
        expected = meta_pattern.sub("", expected)
        check_html(text, expected)
        self.assertEqual(mode, 'r')
        self.assertEqual(encoding, 'latin-1')
        self.assertEqual(type_, 'text/html')

    def test_read_xml_file(self):
        ob = self._makeOne('input/sample.xml')
        text, type_, encoding, mode = ob.read_file()
        expected = open('input/sample.xml', 'rb').read()
        check_xml(text, expected)
        self.assertEqual(mode, 'rb')
        self.assertEqual(encoding, None)
        self.assertEqual(type_, 'text/xml')

    def test_cook(self):
        ob = self._makeOne('input/sample.html')
        self.assertEqual(ob._v_element, None)
        ob._cook()
        self.assertEqual(ob._v_element.tag, 'html')

    def test_call(self):
        ob = self._makeOne('input/sample.html')
        instance = dummy()
        expected = open('input/sample.html', 'r').read()
        from meldtemplatefile import meta_pattern
        expected = meta_pattern.sub("", expected)
        actual = ob(instance)
        io = StringIO()
        ob._v_element.write_html(io)
        io.seek(0)
        expected = io.read()
        check_html(actual, expected)
        self.assertEqual(instance.request.response.names['Content-Type'],
                         'text/html')


class MeldZCMLTests(unittest.TestCase):
    def test_register(self):
        from z3meld.metaconfigure import MeldViewClass
        from zope.publisher.interfaces.browser import IDefaultBrowserLayer
        from zope.component import getMultiAdapter, provideAdapter, getAdapters
        from zope.app.publisher.interfaces.browser import IBrowserView

        factory = MeldViewClass('input/sample.html', name='foo')

        provideAdapter(factory, (None, IBrowserRequest), Interface,
                       name='foo')
        request = dummyrequest()
        content = dummy()

        ob = getMultiAdapter((content, request), name='foo')
        self.assertEqual(ob.__name__, 'foo')
        self.failUnless(ob.index.filename.endswith('sample.html'))

        
    def test_config(self):
        config = """<configure
    xmlns="http://namespaces.zope.org/zope"
    xmlns:meta="http://namespaces.zope.org/meta"
    xmlns:browser="http://namespaces.zope.org/browser">

  <include file="meta.zcml"
           package="z3meld"/>

  <browser:meld3page
      for="*"
      name="foo.html"
      template="input/sample.html"
      permission="zope.Public"/>

</configure>
"""
        tf = open('temp.zcml', 'w')
        tf.write(config)
        tf.flush()
        tf.close()

        from zope.configuration import xmlconfig
        import sys
        import z3meld
        context = xmlconfig.file('temp.zcml', package=z3meld)

        from zope.component import getMultiAdapter, getView

        request = dummyrequest()
        content = dummy()

        ob = getMultiAdapter((content, request), name='foo.html')
        self.assertEqual(ob.__name__, 'foo.html')
        self.failUnless(ob.index.filename.endswith('sample.html'))
        

class dummyresponse:
    def __init__(self):
        self.names = {}
        
    def getHeader(self, name):
        return None

    def setHeader(self, name, value):
        self.names[name] = value

class dummyrequest:
    implements(IDefaultBrowserLayer)
    def __init__(self):
        self.response = dummyresponse()
        
    def getPresentationSkin(self):
        return None

    def has_key(self, key):
        return False

class IDummy(Interface):
    pass

class dummy:
    implements(IDummy)
    def __init__(self):
        self.request = dummyrequest()

def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(MeldTemplateFileTests))
    suite.addTest(unittest.makeSuite(MeldZCMLTests))
    return suite

if __name__ == '__main__':
    unittest.TextTestRunner().run(test_suite())