Skip to content
Snippets Groups Projects
Commit 4d89672e authored by Xavier Morel's avatar Xavier Morel
Browse files

[REM] tests, they're apparently considered non-essential and nobody gives a shit 

bzr revid: xmo@openerp.com-20110902085919-es2ash6j5he5kv3q
parent 80d08598
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
addons/base/common/tests/__init__.py deleted 100644 → 0
+ 0
− 1
View file @ 80d08598
# -*- coding: utf-8 -*-
addons/base/common/tests/test_model.py deleted 100644 → 0
+ 0
− 81
View file @ 80d08598
# -*- coding: utf-8 -*-
import cherrypy
import mock
import unittest2
import openerpweb.openerpweb
class OpenERPModelTest(unittest2.TestCase):
def test_rpc_call(self):
session = mock.Mock(['execute'])
Model = openerpweb.openerpweb.OpenERPModel(
session, 'a.b')
Model.search([('field', 'op', 'value')], {'key': 'value'})
session.execute.assert_called_once_with(
'a.b', 'search', [('field', 'op', 'value')], {'key': 'value'})
session.execute.reset_mock()
Model.read([42])
session.execute.assert_called_once_with(
'a.b', 'read', [42])
class FakeController(object):
pass
class DispatcherTest(unittest2.TestCase):
def setUp(self):
controller = FakeController()
self.mock_method = mock.Mock()
controller.method = self.mock_method
self.mock_method.exposed = True
self.mock_index = mock.Mock()
controller.index = self.mock_index
self.mock_index.exposed = True
self.patcher = mock.patch.dict(
openerpweb.openerpweb.controllers_path,
{'/some/controller/path': controller})
self.patcher.start()
controller2 = FakeController()
controller2.index = self.mock_index
self.patcher2 = mock.patch.dict(
openerpweb.openerpweb.controllers_path,
{'/some/other/controller': FakeController(),
'/some/other/controller/2': controller2})
self.patcher2.start()
def tearDown(self):
self.patcher2.stop()
self.patcher.stop()
def test_default_redirect(self):
self.assertRaises(
cherrypy.HTTPRedirect,
openerpweb.openerpweb.Root().find_handler)
def test_serve_static_missing(self):
self.assertRaises(
cherrypy.NotFound,
openerpweb.openerpweb.Root().find_handler,
'does-not-exist', 'static', 'bar')
def test_serve_controller_missing(self):
self.assertRaises(
cherrypy.NotFound,
openerpweb.openerpweb.Root().find_handler,
'controller', 'does', 'not', 'exist')
def test_find_controller_method(self):
openerpweb.openerpweb.Root().find_handler(
'some', 'controller', 'path', 'method')
self.mock_method.assert_called_once_with()
def test_find_controller_index(self):
openerpweb.openerpweb.Root().find_handler(
'some', 'controller', 'path')
self.mock_index.assert_called_once_with()
def test_nested_paths(self):
openerpweb.openerpweb.Root().find_handler(
'some', 'other', 'controller', '2')
self.mock_index.assert_called_once_with()
addons/base/common/tests/test_nonliterals.py deleted 100644 → 0
+ 0
− 145
View file @ 80d08598
# -*- coding: utf-8 -*-
import mock
import simplejson
import unittest2
from openerpweb.nonliterals import Domain, Context
import openerpweb.nonliterals
import openerpweb.openerpweb
class NonLiteralDomainTest(unittest2.TestCase):
def setUp(self):
self.session = mock.Mock(spec=openerpweb.openerpweb.OpenERPSession)
self.session.domains_store = {}
def test_store_domain(self):
d = Domain(self.session, "some arbitrary string")
self.assertEqual(
self.session.domains_store[d.key],
"some arbitrary string")
def test_get_domain_back(self):
d = Domain(self.session, "some arbitrary string")
self.assertEqual(
d.get_domain_string(),
"some arbitrary string")
def test_retrieve_second_domain(self):
""" A different domain should be able to retrieve the nonliteral set
previously
"""
key = Domain(self.session, "some arbitrary string").key
self.assertEqual(
Domain(self.session, key=key).get_domain_string(),
"some arbitrary string")
def test_key_and_string(self):
self.assertRaises(
ValueError, Domain, None, domain_string="a", key="b")
def test_eval(self):
self.session.evaluation_context.return_value = {'foo': 3}
result = Domain(self.session, "[('a', '=', foo)]").evaluate({'foo': 3})
self.assertEqual(
result, [('a', '=', 3)])
def test_own_values(self):
self.session.evaluation_context.return_value = {}
domain = Domain(self.session, "[('a', '=', self)]")
domain.own = {'self': 3}
result = domain.evaluate()
self.assertEqual(
result, [('a', '=', 3)])
class NonLiteralContextTest(unittest2.TestCase):
def setUp(self):
self.session = mock.Mock(spec=openerpweb.openerpweb.OpenERPSession)
self.session.contexts_store = {}
def test_store_domain(self):
c = Context(self.session, "some arbitrary string")
self.assertEqual(
self.session.contexts_store[c.key],
"some arbitrary string")
def test_get_domain_back(self):
c = Context(self.session, "some arbitrary string")
self.assertEqual(
c.get_context_string(),
"some arbitrary string")
def test_retrieve_second_domain(self):
""" A different domain should be able to retrieve the nonliteral set
previously
"""
key = Context(self.session, "some arbitrary string").key
self.assertEqual(
Context(self.session, key=key).get_context_string(),
"some arbitrary string")
def test_key_and_string(self):
self.assertRaises(
ValueError, Context, None, context_string="a", key="b")
def test_eval(self):
self.session.evaluation_context.return_value = {'foo': 3}
result = Context(self.session, "[('a', '=', foo)]")\
.evaluate({'foo': 3})
self.assertEqual(
result, [('a', '=', 3)])
def test_own_values(self):
self.session.evaluation_context.return_value = {}
context = Context(self.session, "{'a': self}")
context.own = {'self': 3}
result = context.evaluate()
self.assertEqual(
result, {'a': 3})
class NonLiteralJSON(unittest2.TestCase):
def setUp(self):
self.session = mock.Mock(spec=openerpweb.openerpweb.OpenERPSession)
self.session.domains_store = {}
self.session.contexts_store = {}
def test_encode_domain(self):
d = Domain(self.session, "some arbitrary string")
self.assertEqual(
simplejson.dumps(d, cls=openerpweb.nonliterals.NonLiteralEncoder),
simplejson.dumps({'__ref': 'domain', '__id': d.key}))
def test_decode_domain(self):
encoded = simplejson.dumps(
Domain(self.session, "some arbitrary string"),
cls=openerpweb.nonliterals.NonLiteralEncoder)
domain = simplejson.loads(
encoded, object_hook=openerpweb.nonliterals.non_literal_decoder)
domain.session = self.session
self.assertEqual(
domain.get_domain_string(),
"some arbitrary string"
)
def test_encode_context(self):
c = Context(self.session, "some arbitrary string")
self.assertEqual(
simplejson.dumps(c, cls=openerpweb.nonliterals.NonLiteralEncoder),
simplejson.dumps({'__ref': 'context', '__id': c.key}))
def test_decode_context(self):
encoded = simplejson.dumps(
Context(self.session, "some arbitrary string"),
cls=openerpweb.nonliterals.NonLiteralEncoder)
context = simplejson.loads(
encoded, object_hook=openerpweb.nonliterals.non_literal_decoder)
context.session = self.session
self.assertEqual(
context.get_context_string(),
"some arbitrary string"
)
addons/base/common/tests/test_session.py deleted 100644 → 0
+ 0
− 110
View file @ 80d08598
# -*- coding: utf-8 -*-
import unittest2
from openerpweb.nonliterals import Domain, Context, CompoundDomain, CompoundContext
import openerpweb.openerpweb
class TestOpenERPSession(unittest2.TestCase):
def setUp(self):
self.module = object()
self.session = openerpweb.openerpweb.OpenERPSession()
self.session._uid = -1
self.session.context = {
'current_date': '1945-08-05',
'date': self.module,
'time': self.module,
'datetime': self.module,
'relativedelta': self.module
}
def test_base_eval_context(self):
self.assertEqual(type(self.session.base_eval_context), dict)
self.assertEqual(
self.session.base_eval_context,
{'uid': -1, 'current_date': '1945-08-05',
'date': self.module, 'datetime': self.module, 'time': self.module,
'relativedelta': self.module}
)
def test_evaluation_context_nocontext(self):
self.assertEqual(
type(self.session.evaluation_context()),
dict
)
self.assertEqual(
self.session.evaluation_context(),
self.session.base_eval_context
)
def test_evaluation_context(self):
ctx = self.session.evaluation_context({'foo': 3})
self.assertEqual(
type(ctx),
dict
)
self.assertIn('foo', ctx)
def test_eval_with_context(self):
self.assertEqual(
eval('current_date', self.session.evaluation_context()),
'1945-08-05')
self.assertEqual(
eval('foo + 3', self.session.evaluation_context({'foo': 4})),
7)
def test_eval_domain_typeerror(self):
self.assertRaises(
TypeError, self.session.eval_domain, "foo")
def test_eval_domain_list(self):
self.assertEqual(
self.session.eval_domain([]),
[])
def test_eval_nonliteral_domain(self):
d = Domain(self.session, "[('foo', 'is', 3)]")
self.assertEqual(
self.session.eval_domain(d),
[('foo', 'is', 3)])
def test_eval_nonliteral_domain_bykey(self):
key = Domain(
self.session, "[('foo', 'is', 3)]").key
d = Domain(None, key=key)
self.assertEqual(
self.session.eval_domain(d),
[('foo', 'is', 3)])
def test_eval_empty_domains(self):
self.assertEqual(
self.session.eval_domain(CompoundDomain()),
[])
def test_eval_literal_domains(self):
domains = [
[('a', 'is', 3)],
[('b', 'ilike', 'foo')],
['|',
('c', '=', False),
('c', 'in', ['a', 'b', 'c'])]
]
self.assertEqual(
self.session.eval_domain(CompoundDomain(*domains)),
[
('a', 'is', 3),
('b', 'ilike', 'foo'),
'|',
('c', '=', False),
('c', 'in', ['a', 'b', 'c'])
])
def test_eval_nonliteral_domains(self):
domains = [
Domain(self.session, "[('uid', '=', uid)]"),
Domain(self.session,
"['|', ('date', '<', current_date),"
" ('date', '>', current_date)]")]
self.assertEqual(
self.session.eval_domain(CompoundDomain(*domains)),
[('uid', '=', -1),
'|', ('date', '<', '1945-08-05'), ('date', '>', '1945-08-05')]
)
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment