Fix bug in Encoder where tuples were encoded into lists. Fix Encoder and Command.args_options_2_entry unit tests.

2 files changed, 50 insertions, 42 deletions

diff --git a/tests/test_ipalib/test_encoder.py b/tests/test_ipalib/test_encoder.py
index 7b73a3859..f677e8524 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 0116b1b50..170891eea 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