Пример #1
0
 def test_create_new_module(self):
     mv1 = ModuleVersion.create_or_replace_from_spec({
         'id_name': 'x', 'name': 'x', 'category': 'Clean', 'parameters': []
     }, source_version_hash='a')
     mv2 = ModuleVersion.create_or_replace_from_spec({
         'id_name': 'y', 'name': 'x', 'category': 'Clean', 'parameters': []
     }, source_version_hash='a')
     self.assertNotEqual(mv1.id, mv2.id)
Пример #2
0
    def test_create_overwrite_version(self):
        mv1 = ModuleVersion.create_or_replace_from_spec({
            'id_name': 'x', 'name': 'x', 'category': 'Clean',
            'parameters': [{'id_name': 'x', 'type': 'string'}]
        }, source_version_hash='a')
        mv2 = ModuleVersion.create_or_replace_from_spec({
            'id_name': 'x', 'name': 'x', 'category': 'Clean', 'parameters': []
        }, source_version_hash='a')

        self.assertEqual(mv1.id, mv2.id)
Пример #3
0
    def test_default_params(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                'id_name':
                'x',
                'name':
                'x',
                'category':
                'Clean',
                'parameters': [
                    {
                        'id_name': 'foo',
                        'type': 'string',
                        'default': 'X'
                    },
                    {
                        'id_name': 'bar',
                        'type': 'secret',
                        'name': 'Secret'
                    },
                    {
                        'id_name': 'baz',
                        'type': 'menu',
                        'menu_items': 'a|b|c',
                        'default': 2
                    },
                ]
            },
            source_version_hash='1.0')

        self.assertEqual(mv.default_params, {'foo': 'X', 'baz': 2})
    def test_param_schema_implicit(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                "id_name":
                "x",
                "name":
                "x",
                "category":
                "Clean",
                "parameters": [
                    {
                        "id_name": "foo",
                        "type": "string",
                        "default": "X"
                    },
                    {
                        "id_name": "bar",
                        "type": "secret",
                        "secret_logic": {
                            "provider": "oauth",
                            "service": "google"
                        },
                    },
                    {
                        "id_name":
                        "baz",
                        "type":
                        "menu",
                        "options": [
                            {
                                "value": "a",
                                "label": "A"
                            },
                            "separator",
                            {
                                "value": "c",
                                "label": "C"
                            },
                        ],
                        "default":
                        "c",
                    },
                ],
            },
            source_version_hash="1.0",
        )

        self.assertEqual(
            repr(mv.param_schema),
            repr(
                ParamDType.Dict({
                    "foo":
                    ParamDType.String(default="X"),
                    # secret is not in param_schema
                    "baz":
                    ParamDType.Enum(choices=frozenset({"a", "c"}),
                                    default="c"),
                })),
        )
Пример #5
0
    def test_param_schema_implicit(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                'id_name':
                'x',
                'name':
                'x',
                'category':
                'Clean',
                'parameters': [
                    {
                        'id_name': 'foo',
                        'type': 'string',
                        'default': 'X'
                    },
                    {
                        'id_name': 'bar',
                        'type': 'secret',
                        'secret_logic': {
                            'provider': 'oauth',
                            'service': 'google'
                        }
                    },
                    {
                        'id_name':
                        'baz',
                        'type':
                        'menu',
                        'options': [
                            {
                                'value': 'a',
                                'label': 'A'
                            },
                            'separator',
                            {
                                'value': 'c',
                                'label': 'C'
                            },
                        ],
                        'default':
                        'c'
                    },
                ]
            },
            source_version_hash='1.0')

        self.assertEqual(
            repr(mv.param_schema),
            repr(
                ParamDType.Dict({
                    'foo':
                    ParamDType.String(default='X'),
                    # secret is not in param_schema
                    'baz':
                    ParamDType.Enum(choices=frozenset({'a', 'c'}),
                                    default='c'),
                })))
 def test_uses_data_default_true_if_loads_data_false(self):
     mv = ModuleVersion.create_or_replace_from_spec({
         "id_name": "idname",
         "name": "Name",
         "category": "Add data",
         "parameters": [],
         "loads_data": True,
     })
     self.assertFalse(mv.uses_data)
Пример #7
0
 def test_uses_data_default_true_if_loads_data_false(self):
     mv = ModuleVersion.create_or_replace_from_spec({
         'id_name': 'idname',
         'name': 'Name',
         'category': 'Add data',
         'parameters': [],
         'loads_data': True,
     })
     self.assertFalse(mv.uses_data)
 def test_uses_data_override(self):
     mv = ModuleVersion.create_or_replace_from_spec({
         "id_name": "idname",
         "name": "Name",
         "category": "Add data",
         "parameters": [],
         "loads_data": True,
         "uses_data": True,
     })
     self.assertTrue(mv.uses_data)
Пример #9
0
 def test_uses_data_override(self):
     mv = ModuleVersion.create_or_replace_from_spec({
         'id_name': 'idname',
         'name': 'Name',
         'category': 'Add data',
         'parameters': [],
         'loads_data': True,
         'uses_data': True,
     })
     self.assertTrue(mv.uses_data)
Пример #10
0
 def test_create_new_module(self):
     mv1 = ModuleVersion.create_or_replace_from_spec(
         {
             "id_name": "x",
             "name": "x",
             "category": "Clean",
             "parameters": []
         },
         source_version_hash="a",
     )
     mv2 = ModuleVersion.create_or_replace_from_spec(
         {
             "id_name": "y",
             "name": "x",
             "category": "Clean",
             "parameters": []
         },
         source_version_hash="a",
     )
     self.assertNotEqual(mv1.id, mv2.id)
Пример #11
0
 def test_create_module_properties(self):
     mv = ModuleVersion.create_or_replace_from_spec({
         'id_name': 'idname',
         'name': 'Name',
         'category': 'Clean',
         'link': 'http://foo.com',
         'help_url': 'a/b/c',
         'parameters': []
     }, source_version_hash='1.0')
     self.assertFalse(mv.id is None)  # it saved
     mv.refresh_from_db()
     self.assertEqual(mv.id_name, 'idname')
     self.assertEqual(mv.name, 'Name')
     self.assertEqual(mv.category, 'Clean')
     self.assertEqual(mv.help_url, 'a/b/c')
Пример #12
0
    def test_create_overwrite_version(self):
        mv1 = ModuleVersion.create_or_replace_from_spec(
            {
                "id_name": "x",
                "name": "x",
                "category": "Clean",
                "parameters": [{
                    "id_name": "x",
                    "type": "string"
                }],
            },
            source_version_hash="a",
        )
        mv2 = ModuleVersion.create_or_replace_from_spec(
            {
                "id_name": "x",
                "name": "x",
                "category": "Clean",
                "parameters": []
            },
            source_version_hash="a",
        )

        self.assertEqual(mv1.id, mv2.id)
Пример #13
0
 def test_create_module_properties(self):
     mv = ModuleVersion.create_or_replace_from_spec(
         {
             "id_name": "idname",
             "name": "Name",
             "category": "Clean",
             "link": "http://foo.com",
             "help_url": "a/b/c",
             "parameters": [],
         },
         source_version_hash="1.0",
     )
     self.assertFalse(mv.id is None)  # it saved
     mv.refresh_from_db()
     self.assertEqual(mv.id_name, "idname")
     self.assertEqual(mv.name, "Name")
     self.assertEqual(mv.category, "Clean")
     self.assertEqual(mv.help_url, "a/b/c")
Пример #14
0
    def test_default_params(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                "id_name":
                "x",
                "name":
                "x",
                "category":
                "Clean",
                "parameters": [{
                    "id_name": "foo",
                    "type": "string",
                    "default": "X"
                }],
            },
            source_version_hash="1.0",
        )

        self.assertEqual(mv.default_params, {"foo": "X"})
Пример #15
0
    def test_default_params(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                'id_name':
                'x',
                'name':
                'x',
                'category':
                'Clean',
                'parameters': [
                    {
                        'id_name': 'foo',
                        'type': 'string',
                        'default': 'X'
                    },
                ]
            },
            source_version_hash='1.0')

        self.assertEqual(mv.default_params, {'foo': 'X'})
Пример #16
0
    def test_param_schema_implicit(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                'id_name':
                'x',
                'name':
                'x',
                'category':
                'Clean',
                'parameters': [
                    {
                        'id_name': 'foo',
                        'type': 'string',
                        'default': 'X'
                    },
                    {
                        'id_name': 'bar',
                        'type': 'secret',
                        'name': 'Secret'
                    },
                    {
                        'id_name': 'baz',
                        'type': 'menu',
                        'menu_items': 'a|b|c',
                        'default': 2
                    },
                ]
            },
            source_version_hash='1.0')

        self.assertEqual(
            repr(mv.param_schema),
            repr(
                ParamDType.Dict({
                    'foo':
                    ParamDType.String(default='X'),
                    'baz':
                    ParamDType.Enum(choices={0, 1, 2}, default=2),
                })))
Пример #17
0
    def test_param_schema_explicit(self):
        mv = ModuleVersion.create_or_replace_from_spec(
            {
                "id_name": "x",
                "name": "x",
                "category": "Clean",
                "parameters": [{
                    "id_name": "whee",
                    "type": "custom"
                }],
                "param_schema": {
                    "id_name": {
                        "type": "dict",
                        "properties": {
                            "x": {
                                "type": "integer"
                            },
                            "y": {
                                "type": "string",
                                "default": "X"
                            },
                        },
                    }
                },
            },
            source_version_hash="1.0",
        )

        self.assertEqual(
            repr(mv.param_schema),
            repr(
                ParamDType.Dict({
                    "id_name":
                    ParamDType.Dict({
                        "x": ParamDType.Integer(),
                        "y": ParamDType.String(default="X"),
                    })
                })),
        )
Пример #18
0
    def test_param_schema_explicit(self):
        mv = ModuleVersion.create_or_replace_from_spec({
            'id_name': 'x', 'name': 'x', 'category': 'Clean',
            'parameters': [
                {'id_name': 'whee', 'type': 'custom'}
            ],
            'param_schema': {
                'id_name': {
                    'type': 'dict',
                    'properties': {
                        'x': {'type': 'integer'},
                        'y': {'type': 'string', 'default': 'X'},
                    },
                },
            },
        }, source_version_hash='1.0')

        self.assertEqual(repr(mv.param_schema), repr(ParamDType.Dict({
            'id_name': ParamDType.Dict({
                'x': ParamDType.Integer(),
                'y': ParamDType.String(default='X'),
            }),
        })))