Esempio n. 1
0
    def test_list_dtype(self):
        # Check that ParamSpec's with List type produce correct nested DTypes
        param_spec = ParamSpec.from_dict(
            dict(id_name='p',
                 type='list',
                 child_parameters=[
                     {
                         'id_name': 'intparam',
                         'type': 'integer',
                         'name': 'my number'
                     },
                     {
                         'id_name': 'colparam',
                         'type': 'column',
                         'name': 'my column'
                     },
                 ]))
        self.assertEqual(
            param_spec,
            ParamSpec.List(id_name='p',
                           child_parameters=[
                               ParamSpec.Integer(id_name='intparam',
                                                 name='my number'),
                               ParamSpec.Column(id_name='colparam',
                                                name='my column'),
                           ]))
        dtype = param_spec.dtype
        expected_dtype = DT.List(
            DT.Dict({
                'intparam': DT.Integer(),
                'colparam': DT.Column(),
            }))

        # effectively do a deep compare with repr
        self.assertEqual(repr(dtype), repr(expected_dtype))
Esempio n. 2
0
    def test_to_dict_dict_factory(self):
        def upcasedict(tuples):
            return dict((x.upper(), y) for x, y in tuples)

        param_spec = ParamSpec.List(id_name='l',
                                    visible_if=dict(id_name='othermenu',
                                                    value='showlist'),
                                    child_parameters=[
                                        ParamSpec.String(id_name='s',
                                                         default='foo'),
                                        ParamSpec.Column(id_name='c',
                                                         visible_if=dict(
                                                             id_name='s',
                                                             value='iddqd')),
                                    ])
        param_dict = param_spec.to_dict(dict_factory=upcasedict)
        self.assertEqual(
            param_dict, {
                'TYPE':
                'list',
                'ID_NAME':
                'l',
                'NAME':
                '',
                'VISIBLE_IF': {
                    'ID_NAME': 'othermenu',
                    'VALUE': 'showlist'
                },
                'CHILD_PARAMETERS': [
                    {
                        'TYPE': 'string',
                        'ID_NAME': 's',
                        'NAME': '',
                        'DEFAULT': 'foo',
                        'MULTILINE': False,
                        'PLACEHOLDER': '',
                        'VISIBLE_IF': None,
                    },
                    {
                        'TYPE': 'column',
                        'ID_NAME': 'c',
                        'PLACEHOLDER': '',
                        'NAME': '',
                        'TAB_PARAMETER': None,
                        'COLUMN_TYPES': None,
                        'VISIBLE_IF': {
                            'ID_NAME': 's',
                            'VALUE': 'iddqd',
                        },
                    },
                ]
            })
Esempio n. 3
0
 def test_to_dict(self):
     param_spec = ParamSpec.List(id_name='l',
                                 child_parameters=[
                                     ParamSpec.String(id_name='s',
                                                      default='foo'),
                                     ParamSpec.Column(id_name='c',
                                                      visible_if=dict(
                                                          id_name='s',
                                                          value='iddqd')),
                                 ])
     param_dict = param_spec.to_dict()
     self.assertEqual(
         param_dict, {
             'type':
             'list',
             'id_name':
             'l',
             'name':
             '',
             'visible_if':
             None,
             'child_parameters': [
                 {
                     'type': 'string',
                     'id_name': 's',
                     'name': '',
                     'default': 'foo',
                     'multiline': False,
                     'placeholder': '',
                     'visible_if': None,
                 },
                 {
                     'type': 'column',
                     'id_name': 'c',
                     'placeholder': '',
                     'name': '',
                     'tab_parameter': None,
                     'column_types': None,
                     'visible_if': {
                         'id_name': 's',
                         'value': 'iddqd',
                     },
                 },
             ]
         })
     # Just to make sure our unit-test is sane: verify from_dict(to_json)
     # returns the original.
     self.assertEqual(ParamSpec.from_dict(param_dict), param_spec)