2013-04-25 09:37:39 +00:00
|
|
|
# -*- encoding: utf-8 -*-
|
2013-04-22 09:10:14 +00:00
|
|
|
from lxml import etree as ET
|
2013-04-25 09:37:39 +00:00
|
|
|
from lxml.builder import E, ElementMaker
|
2013-04-22 09:10:14 +00:00
|
|
|
|
2013-04-24 15:43:10 +00:00
|
|
|
from openerp.tests import common
|
2013-04-24 09:51:14 +00:00
|
|
|
import unittest2
|
2013-04-22 09:10:14 +00:00
|
|
|
|
|
|
|
Field = E.field
|
|
|
|
|
|
|
|
class TestNodeLocator(common.BaseCase):
|
|
|
|
"""
|
|
|
|
The node locator returns None when it can not find a node, and the first
|
|
|
|
match when it finds something (no jquery-style node sets)
|
|
|
|
"""
|
|
|
|
def setUp(self):
|
|
|
|
super(TestNodeLocator, self).setUp()
|
|
|
|
self.Views = self.registry('ir.ui.view')
|
|
|
|
|
|
|
|
def test_no_match_xpath(self):
|
|
|
|
"""
|
|
|
|
xpath simply uses the provided @expr pattern to find a node
|
|
|
|
"""
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(), E.bar(), E.baz()),
|
|
|
|
E.xpath(expr="//qux"))
|
|
|
|
self.assertIsNone(node)
|
|
|
|
|
|
|
|
def test_match_xpath(self):
|
|
|
|
bar = E.bar()
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(), bar, E.baz()),
|
|
|
|
E.xpath(expr="//bar"))
|
|
|
|
self.assertIs(node, bar)
|
|
|
|
|
|
|
|
|
|
|
|
def test_no_match_field(self):
|
|
|
|
"""
|
|
|
|
A field spec will match by @name against all fields of the view
|
|
|
|
"""
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(), E.bar(), E.baz()),
|
|
|
|
Field(name="qux"))
|
|
|
|
self.assertIsNone(node)
|
|
|
|
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(Field(name="foo"), Field(name="bar"), Field(name="baz")),
|
|
|
|
Field(name="qux"))
|
|
|
|
self.assertIsNone(node)
|
|
|
|
|
|
|
|
def test_match_field(self):
|
|
|
|
bar = Field(name="bar")
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(Field(name="foo"), bar, Field(name="baz")),
|
|
|
|
Field(name="bar"))
|
|
|
|
self.assertIs(node, bar)
|
|
|
|
|
|
|
|
|
|
|
|
def test_no_match_other(self):
|
|
|
|
"""
|
|
|
|
Non-xpath non-fields are matched by node name first
|
|
|
|
"""
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(), E.bar(), E.baz()),
|
|
|
|
E.qux())
|
|
|
|
self.assertIsNone(node)
|
|
|
|
|
|
|
|
def test_match_other(self):
|
|
|
|
bar = E.bar()
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(), bar, E.baz()),
|
|
|
|
E.bar())
|
|
|
|
self.assertIs(bar, node)
|
|
|
|
|
|
|
|
def test_attribute_mismatch(self):
|
|
|
|
"""
|
|
|
|
Non-xpath non-field are filtered by matching attributes on spec and
|
|
|
|
matched nodes
|
|
|
|
"""
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(attr='1'), E.bar(attr='2'), E.baz(attr='3')),
|
|
|
|
E.bar(attr='5'))
|
|
|
|
self.assertIsNone(node)
|
|
|
|
|
|
|
|
def test_attribute_filter(self):
|
|
|
|
match = E.bar(attr='2')
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.bar(attr='1'), match, E.root(E.bar(attr='3'))),
|
|
|
|
E.bar(attr='2'))
|
|
|
|
self.assertIs(node, match)
|
|
|
|
|
|
|
|
def test_version_mismatch(self):
|
|
|
|
"""
|
|
|
|
A @version on the spec will be matched against the view's version
|
|
|
|
"""
|
|
|
|
node = self.Views.locate_node(
|
|
|
|
E.root(E.foo(attr='1'), version='4'),
|
|
|
|
E.foo(attr='1', version='3'))
|
|
|
|
self.assertIsNone(node)
|
2013-04-22 12:28:12 +00:00
|
|
|
|
|
|
|
class TestViewInheritance(common.TransactionCase):
|
2013-04-24 09:51:14 +00:00
|
|
|
def arch_for(self, name, view_type='form'):
|
|
|
|
return ET.tostring(ET.Element(view_type, string=name))
|
2013-04-22 12:28:12 +00:00
|
|
|
|
2013-04-24 09:51:14 +00:00
|
|
|
def makeView(self, name, parent=None, arch=None):
|
2013-06-24 16:09:10 +00:00
|
|
|
v = {
|
2013-04-22 12:28:12 +00:00
|
|
|
'model': self.model,
|
|
|
|
'name': name,
|
2013-04-24 09:51:14 +00:00
|
|
|
'arch': arch or self.arch_for(name),
|
2013-04-23 13:25:23 +00:00
|
|
|
'inherit_id': parent,
|
2013-06-24 16:09:10 +00:00
|
|
|
}
|
|
|
|
view_id = self.View.create(self.cr, self.uid, v)
|
2013-04-22 12:28:12 +00:00
|
|
|
self.ids[name] = view_id
|
|
|
|
return view_id
|
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
super(TestViewInheritance, self).setUp()
|
|
|
|
|
|
|
|
self.model = 'dummy'
|
|
|
|
self.View = self.registry('ir.ui.view')
|
2013-04-22 14:01:16 +00:00
|
|
|
self._init = self.View.pool._init
|
|
|
|
self.View.pool._init = False
|
2013-04-22 12:28:12 +00:00
|
|
|
self.ids = {}
|
|
|
|
|
|
|
|
a = self.makeView("A")
|
|
|
|
a1 = self.makeView("A1", a)
|
|
|
|
a11 = self.makeView("A11", a1)
|
|
|
|
self.makeView("A111", a11)
|
|
|
|
self.makeView("A12", a1)
|
|
|
|
a2 = self.makeView("A2", a)
|
|
|
|
self.makeView("A21", a2)
|
|
|
|
a22 = self.makeView("A22", a2)
|
|
|
|
self.makeView("A221", a22)
|
|
|
|
|
2013-04-24 09:51:14 +00:00
|
|
|
b = self.makeView('B', arch=self.arch_for("B", 'tree'))
|
|
|
|
self.makeView('B1', b, arch=self.arch_for("B1", 'tree'))
|
|
|
|
c = self.makeView('C', arch=self.arch_for("C", 'tree'))
|
|
|
|
self.View.write(self.cr, self.uid, c, {'priority': 1})
|
|
|
|
|
2013-04-22 14:01:16 +00:00
|
|
|
def tearDown(self):
|
|
|
|
self.View.pool._init = self._init
|
|
|
|
super(TestViewInheritance, self).tearDown()
|
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_get_inheriting_views_arch(self):
|
2013-04-22 12:28:12 +00:00
|
|
|
self.assertEqual(self.View.get_inheriting_views_arch(
|
|
|
|
self.cr, self.uid, self.ids['A'], self.model), [
|
2013-04-24 09:51:14 +00:00
|
|
|
(self.arch_for('A1'), self.ids['A1']),
|
|
|
|
(self.arch_for('A2'), self.ids['A2']),
|
2013-04-22 12:28:12 +00:00
|
|
|
])
|
|
|
|
|
|
|
|
self.assertEqual(self.View.get_inheriting_views_arch(
|
|
|
|
self.cr, self.uid, self.ids['A21'], self.model),
|
|
|
|
[])
|
|
|
|
|
|
|
|
self.assertEqual(self.View.get_inheriting_views_arch(
|
|
|
|
self.cr, self.uid, self.ids['A11'], self.model),
|
2013-04-24 09:51:14 +00:00
|
|
|
[(self.arch_for('A111'), self.ids['A111'])])
|
2013-04-22 12:50:00 +00:00
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_iter(self):
|
2013-04-22 12:50:00 +00:00
|
|
|
descendents = list(self.View.iter(self.cr, self.uid, self.ids['A1'], self.model))
|
|
|
|
self.assertEqual(descendents, [
|
2013-04-24 09:51:14 +00:00
|
|
|
(self.ids[name], self.arch_for(name))
|
2013-04-22 12:50:00 +00:00
|
|
|
for name in ['A1', 'A11', 'A111', 'A12']
|
|
|
|
])
|
|
|
|
descendents = list(self.View.iter(
|
|
|
|
self.cr, self.uid, self.ids['A2'], self.model, exclude_base=True))
|
|
|
|
self.assertEqual(descendents, [
|
2013-04-24 09:51:14 +00:00
|
|
|
(self.ids[name], self.arch_for(name))
|
2013-04-22 12:50:00 +00:00
|
|
|
for name in ['A21', 'A22', 'A221']
|
|
|
|
])
|
2013-04-23 13:25:23 +00:00
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_root_ancestor(self):
|
2013-04-23 13:25:23 +00:00
|
|
|
A_id = self.ids['A']
|
2013-04-24 09:51:14 +00:00
|
|
|
root_id = self.View.root_ancestor(self.cr, self.uid, view_id=A_id)
|
2013-04-23 15:08:44 +00:00
|
|
|
self.assertEqual(root_id, A_id,
|
2013-04-23 13:25:23 +00:00
|
|
|
"when given a root view, operation should be id")
|
|
|
|
|
2013-04-24 09:51:14 +00:00
|
|
|
root_id = self.View.root_ancestor(
|
2013-04-23 13:25:23 +00:00
|
|
|
self.cr, self.uid, view_id=self.ids['A11'])
|
2013-04-23 15:08:44 +00:00
|
|
|
self.assertEqual(root_id, A_id)
|
2013-04-23 13:25:23 +00:00
|
|
|
|
2013-04-24 09:51:14 +00:00
|
|
|
root_id = self.View.root_ancestor(
|
2013-04-23 13:25:23 +00:00
|
|
|
self.cr, self.uid, view_id=self.ids['A221'])
|
2013-04-23 15:08:44 +00:00
|
|
|
self.assertEqual(root_id, A_id)
|
2013-04-23 13:25:23 +00:00
|
|
|
|
2013-04-24 09:51:14 +00:00
|
|
|
root_id = self.View.root_ancestor(
|
|
|
|
self.cr, self.uid, view_id=self.ids['B1'])
|
|
|
|
self.assertEqual(root_id, self.ids['B'])
|
2013-04-23 13:36:17 +00:00
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_no_root_ancestor(self):
|
2013-04-24 13:09:07 +00:00
|
|
|
with self.assertRaises(self.View.NoViewError):
|
|
|
|
self.View.root_ancestor(self.cr, self.uid, view_id=12345678)
|
2013-04-23 13:36:17 +00:00
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_default_view(self):
|
|
|
|
default = self.View.default_view(
|
|
|
|
self.cr, self.uid, model=self.model, view_type='form')
|
|
|
|
self.assertEqual(default, self.ids['A'])
|
|
|
|
|
|
|
|
default_tree = self.View.default_view(
|
2013-04-23 13:36:17 +00:00
|
|
|
self.cr, self.uid, model=self.model, view_type='tree')
|
2013-04-24 09:51:14 +00:00
|
|
|
self.assertEqual(default_tree, self.ids['C'])
|
2013-04-23 13:36:17 +00:00
|
|
|
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-24 09:51:14 +00:00
|
|
|
def test_no_default_view(self):
|
2013-04-24 13:09:07 +00:00
|
|
|
with self.assertRaises(self.View.NoDefaultError):
|
|
|
|
self.View.default_view(
|
|
|
|
self.cr, self.uid, model='does.not.exist', view_type='form')
|
2013-04-24 09:51:14 +00:00
|
|
|
|
2013-04-24 13:09:07 +00:00
|
|
|
with self.assertRaises(self.View.NoDefaultError):
|
|
|
|
self.View.default_view(
|
|
|
|
self.cr, self.uid, model=self.model, view_type='graph')
|
|
|
|
|
|
|
|
@unittest2.skip("Not tested")
|
|
|
|
def test_apply_inherited_archs(self):
|
|
|
|
self.fail()
|
|
|
|
|
|
|
|
@unittest2.skip("Not tested")
|
|
|
|
def test_apply_inheritance_specs(self):
|
|
|
|
self.fail()
|
2013-04-24 09:51:14 +00:00
|
|
|
|
|
|
|
class TestViewCombined(common.TransactionCase):
|
|
|
|
"""
|
|
|
|
Test fallback operations of View.read_combined:
|
|
|
|
* defaults mapping
|
|
|
|
* ?
|
|
|
|
"""
|
2013-04-25 09:37:39 +00:00
|
|
|
|
|
|
|
class TestNoModel(common.TransactionCase):
|
2013-06-24 16:09:10 +00:00
|
|
|
@unittest2.skip("Not tested")
|
2013-04-25 09:37:39 +00:00
|
|
|
def test_create_view_nomodel(self):
|
|
|
|
View = self.registry('ir.ui.view')
|
|
|
|
view_id = View.create(self.cr, self.uid, {
|
|
|
|
'name': 'dummy',
|
|
|
|
'arch': '<form/>',
|
|
|
|
'inherit_id': False
|
|
|
|
})
|
2013-04-25 10:02:47 +00:00
|
|
|
fields = ['name', 'arch', 'type', 'priority', 'inherit_id', 'model']
|
|
|
|
[view] = View.read(self.cr, self.uid, [view_id], fields)
|
2013-04-25 09:37:39 +00:00
|
|
|
self.assertEqual(view, {
|
|
|
|
'id': view_id,
|
|
|
|
'name': 'dummy',
|
|
|
|
'arch': '<form/>',
|
|
|
|
'type': 'form',
|
|
|
|
'priority': 16,
|
|
|
|
'inherit_id': False,
|
2013-04-26 14:51:13 +00:00
|
|
|
'model': False,
|
2013-04-25 09:37:39 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
arch = E.body(
|
|
|
|
E.div(
|
|
|
|
E.h1("Title"),
|
|
|
|
id="header"),
|
|
|
|
E.p("Welcome!"),
|
|
|
|
E.div(
|
|
|
|
E.hr(),
|
|
|
|
E.p("Copyright copyrighter", {'class': 'legalese'}),
|
|
|
|
id="footer"),
|
|
|
|
{'class': "index"},)
|
|
|
|
def test_fields_mess(self):
|
|
|
|
"""
|
|
|
|
Try to call __view_look_dom_arch without a model provided, will need
|
|
|
|
to be altered once it's broken up into sane components
|
|
|
|
"""
|
|
|
|
View = self.registry('ir.ui.view')
|
|
|
|
|
|
|
|
sarch, fields = View._view__view_look_dom_arch(
|
|
|
|
self.cr, self.uid, None, self.arch, None)
|
|
|
|
|
|
|
|
self.assertEqual(sarch, ET.tostring(self.arch, encoding='utf-8'))
|
|
|
|
self.assertEqual(fields, {})
|
|
|
|
|
|
|
|
def test_mess_translation(self):
|
|
|
|
"""
|
|
|
|
Test if translations work correctly without a model
|
|
|
|
"""
|
|
|
|
View = self.registry('ir.ui.view')
|
|
|
|
self.registry('res.lang').load_lang(self.cr, self.uid, 'fr_FR')
|
|
|
|
self.registry('ir.translation').create(self.cr, self.uid, {
|
|
|
|
'name': '',
|
|
|
|
'type': 'view',
|
|
|
|
'lang': 'fr_FR',
|
|
|
|
'src': 'Copyright copyrighter',
|
|
|
|
'value': u"Copyrighter, tous droits réservés",
|
|
|
|
})
|
|
|
|
sarch, fields = View._view__view_look_dom_arch(
|
|
|
|
self.cr, self.uid, None,self.arch, None, {'lang': 'fr_FR'})
|
|
|
|
self.assertEqual(
|
|
|
|
sarch,
|
|
|
|
ET.tostring(self.arch, encoding='utf-8')
|
|
|
|
.replace('Copyright copyrighter',
|
|
|
|
'Copyrighter, tous droits réservés'))
|
|
|
|
self.assertEqual(fields, {})
|
|
|
|
|