From cda0f85ce531a3250d745d73e099a47ec6787279 Mon Sep 17 00:00:00 2001 From: Pavel Zuna Date: Mon, 25 May 2009 10:12:40 +0200 Subject: Fix bug in Encoder where tuples were encoded into lists. Fix Encoder and Command.args_options_2_entry unit tests. --- tests/test_ipalib/test_encoder.py | 89 ++++++++++++++++++++------------------ tests/test_ipalib/test_frontend.py | 3 ++ 2 files changed, 50 insertions(+), 42 deletions(-) (limited to 'tests/test_ipalib') diff --git a/tests/test_ipalib/test_encoder.py b/tests/test_ipalib/test_encoder.py index 7b73a385..f677e852 100644 --- a/tests/test_ipalib/test_encoder.py +++ b/tests/test_ipalib/test_encoder.py @@ -24,10 +24,13 @@ Test the `ipalib.encoder` module. import string from tests.util import ClassChecker, assert_equal -from ipalib.encoder import Encoder, encode_args, decode_retval +from ipalib.encoder import Encoder, EncoderSettings, encode_args, decode_retval + +_encoder_settings = EncoderSettings() _test_str_d = u'ěščřžýáíé' -_test_str_e = u'ěščřžýáíé'.encode(Encoder.encode_to) +_test_str_e = u'ěščřžýáíé'.encode(_encoder_settings.encode_to) + class test_Encoder(ClassChecker): """ @@ -40,15 +43,16 @@ class test_Encoder(ClassChecker): Test the `ipalib.encoder.Encoder.encode` method. """ o = self.cls() - o.encode_postprocessor = lambda x: x + encode_to = o.encoder_settings.encode_to + o.encoder_settings.encode_postprocessor = lambda x: x # strings - assert_equal(o.encode('ahoj'), 'ahoj'.encode(o.encode_to)) + assert_equal(o.encode('ahoj'), 'ahoj'.encode(encode_to)) assert_equal(o.encode(_test_str_d), _test_str_e) # bool, float, int, long - assert_equal(o.encode(True), str(True).encode(o.encode_to)) - assert_equal(o.encode(1.01), str(1.01).encode(o.encode_to)) - assert_equal(o.encode(1000), str(1000).encode(o.encode_to)) - assert_equal(o.encode(long(1)), str(long(1)).encode(o.encode_to)) + assert_equal(o.encode(True), str(True).encode(encode_to)) + assert_equal(o.encode(1.01), str(1.01).encode(encode_to)) + assert_equal(o.encode(1000), str(1000).encode(encode_to)) + assert_equal(o.encode(long(1)), str(long(1)).encode(encode_to)) # lists expected = [_test_str_e, '1'] assert_equal(o.encode([_test_str_d, 1]), expected) @@ -60,48 +64,49 @@ class test_Encoder(ClassChecker): expected = ('1', ('1', '2', '3')) assert_equal(o.encode((1, (1, 2, 3))), expected) # dicts: only values, no postprocessing - o.encode_dict_keys = False - o.encode_dict_keys_postprocess = False - o.encode_dict_vals = True - o.encode_dict_vals_postprocess = False + o.encoder_settings.encode_dict_keys = False + o.encoder_settings.encode_dict_keys_postprocess = False + o.encoder_settings.encode_dict_vals = True + o.encoder_settings.encode_dict_vals_postprocess = False expected = {_test_str_d: _test_str_e} assert_equal(o.encode({_test_str_d: _test_str_d}), expected) # dicts: only keys, no postprocessing - o.encode_dict_keys = True - o.encode_dict_vals = False + o.encoder_settings.encode_dict_keys = True + o.encoder_settings.encode_dict_vals = False expected = {_test_str_e: _test_str_d} assert_equal(o.encode({_test_str_d: _test_str_d}), expected) # dicts: both keys and values, no postprocessing - o.encode_dict_vals = True + o.encoder_settings.encode_dict_vals = True expected = {_test_str_e: _test_str_e} assert_equal(o.encode({_test_str_d: _test_str_d}), expected) # dicts: both keys and values, postprocessing on keys only - o.encode_dict_keys = True - o.encode_dict_keys_postprocess = True - o.encode_postprocessor = string.upper + o.encoder_settings.encode_dict_keys = True + o.encoder_settings.encode_dict_keys_postprocess = True + o.encoder_settings.encode_postprocessor = string.upper expected = {_test_str_e.upper(): _test_str_e} assert_equal(o.encode({u'ěščřžýáíé': u'ěščřžýáíé'}), expected) # None - o.encode_postprocessor = lambda x: x - o.encode_none = False + o.encoder_settings.encode_postprocessor = lambda x: x + o.encoder_settings.encode_none = False assert_equal(o.encode(None), None) - o.encode_none = True - assert_equal(o.encode(None), str(None).encode(o.encode_to)) + o.encoder_settings.encode_none = True + assert_equal(o.encode(None), str(None).encode(encode_to)) def test_decode(self): """ Test the `ipalib.encoder.Encoder.decode` method. """ o = self.cls() - o.decode_postprocessor = lambda x: x + decode_from = o.encoder_settings.decode_from + o.encoder_settings.decode_postprocessor = lambda x: x # strings - assert_equal(o.decode('ahoj'), 'ahoj'.decode(o.decode_from)) + assert_equal(o.decode('ahoj'), 'ahoj'.decode(decode_from)) assert_equal(o.decode(_test_str_e), _test_str_d) # bool, float, int, long - assert_equal(o.decode('True'), str(True).decode(o.decode_from)) - assert_equal(o.decode('1.01'), str(1.01).decode(o.decode_from)) - assert_equal(o.decode('1000'), str(1000).decode(o.decode_from)) - assert_equal(o.decode('1'), str(long(1)).decode(o.decode_from)) + assert_equal(o.decode('True'), str(True).decode(decode_from)) + assert_equal(o.decode('1.01'), str(1.01).decode(decode_from)) + assert_equal(o.decode('1000'), str(1000).decode(decode_from)) + assert_equal(o.decode('1'), str(long(1)).decode(decode_from)) # lists expected = [_test_str_d, '1'] assert_equal(o.decode([_test_str_e, '1']), expected) @@ -113,32 +118,32 @@ class test_Encoder(ClassChecker): expected = (u'1', (u'1', u'2', u'3')) assert_equal(o.decode(('1', ('1', '2', '3'))), expected) # dicts: only values, no postprocessing - o.decode_dict_keys = False - o.decode_dict_keys_postprocess = False - o.decode_dict_vals = True - o.decode_dict_vals_postprocess = False + o.encoder_settings.decode_dict_keys = False + o.encoder_settings.decode_dict_keys_postprocess = False + o.encoder_settings.decode_dict_vals = True + o.encoder_settings.decode_dict_vals_postprocess = False expected = {_test_str_e: _test_str_d} assert_equal(o.decode({_test_str_e: _test_str_e}), expected) # dicts: only keys, no postprocessing - o.decode_dict_keys = True - o.decode_dict_vals = False + o.encoder_settings.decode_dict_keys = True + o.encoder_settings.decode_dict_vals = False expected = {_test_str_d: _test_str_e} assert_equal(o.decode({_test_str_e: _test_str_e}), expected) # dicts: both keys and values, no postprocessing - o.decode_dict_vals = True + o.encoder_settings.decode_dict_vals = True expected = {_test_str_d: _test_str_d} assert_equal(o.decode({_test_str_e: _test_str_e}), expected) # dicts: both keys and values, postprocessing on keys only - o.decode_dict_keys = True - o.decode_dict_keys_postprocess = True - o.decode_postprocessor = string.upper + o.encoder_settings.decode_dict_keys = True + o.encoder_settings.decode_dict_keys_postprocess = True + o.encoder_settings.decode_postprocessor = string.upper expected = {_test_str_d.upper(): _test_str_d} assert_equal(o.decode({_test_str_e: _test_str_e}), expected) # TODO: dict decoding using a table # None - o.decode_postprocessor = lambda x: x - o.decode_none = False + o.encoder_settings.decode_postprocessor = lambda x: x + o.encoder_settings.decode_none = False assert_equal(o.decode(None), None) - o.decode_none = True - assert_equal(o.decode(None), str(None).decode(o.encode_to)) + o.encoder_settings.decode_none = True + assert_equal(o.decode(None), str(None).decode(decode_from)) diff --git a/tests/test_ipalib/test_frontend.py b/tests/test_ipalib/test_frontend.py index 0116b1b5..170891ee 100644 --- a/tests/test_ipalib/test_frontend.py +++ b/tests/test_ipalib/test_frontend.py @@ -461,7 +461,10 @@ class test_Command(ClassChecker): args = ('one', 'two') kw = dict(three=('three1', 'three2'), four='four') + (api, home) = create_test_api() + api.finalize() o = my_cmd() + o.set_api(api) o.finalize() e = o.run(*args, **kw) assert type(e) is dict -- cgit