Exemple #1
0
    def test_bad_codebases(self):

        # codebases must be a list of either string or BaseParameter types
        self.assertRaisesConfigError(
            "ForceScheduler 'foo': 'codebases' must be a list of strings or CodebaseParameter objects:",
            lambda: ForceScheduler(
                name='foo',
                builderNames=['bar'],
                codebases=[123],
            ))
        self.assertRaisesConfigError(
            "ForceScheduler 'foo': 'codebases' must be a list of strings or CodebaseParameter objects:",
            lambda: ForceScheduler(
                name='foo',
                builderNames=['bar'],
                codebases=[IntParameter('foo')],
            ))

        # codebases cannot be empty
        self.assertRaisesConfigError(
            "ForceScheduler 'foo': 'codebases' cannot be empty; use [CodebaseParameter(codebase='', hide=True)] if needed:",
            lambda: ForceScheduler(
                name='foo', builderNames=['bar'], codebases=[]))

        # codebases cannot be a dictionnary
        self.assertRaisesConfigError(
            "ForceScheduler 'foo': 'codebases' should be a list of strings or CodebaseParameter, not <type 'dict'>",
            lambda: ForceScheduler(name='foo',
                                   builderNames=['bar'],
                                   codebases={'cb': {
                                       'branch': 'trunk'
                                   }}))
 def test_NestedParameter_nullname(self):
     # same as above except "p1" and "any" are skipped
     fields = [
         NestedParameter(name="inner", fields=[
             StringParameter(name='str'),
             AnyPropertyParameter(name='')
         ]),
         IntParameter(name="foo"),
         NestedParameter(name='bar', fields=[
             NestedParameter(
                 name='', fields=[AnyPropertyParameter(name='a')]),
             NestedParameter(
                 name='', fields=[AnyPropertyParameter(name='b')])
         ])
     ]
     self.do_ParameterTest(req=dict(foo='123',
                                    inner_str="bar",
                                    inner_name="hello",
                                    inner_value="world",
                                    reason="because",
                                    bar_a_name="a",
                                    bar_a_value="7",
                                    bar_b_name="b",
                                    bar_b_value="8"),
                           expect=dict(foo=123,
                                       inner=dict(str="bar", hello="world"),
                                       bar={'a': '7', 'b': '8'}),
                           expectKind=dict,
                           klass=NestedParameter, fields=fields, name='')
    def test_bad_codebases(self):

        # codebases must be a list of either string or BaseParameter types
        with self.assertRaisesConfigError(
                "ForceScheduler 'foo': 'codebases' must be a "
                "list of strings or CodebaseParameter objects:"):
            ForceScheduler(name='foo', builderNames=['bar'], codebases=[123],)

        with self.assertRaisesConfigError(
                "ForceScheduler 'foo': 'codebases' must be a "
                "list of strings or CodebaseParameter objects:"):
            ForceScheduler(name='foo', builderNames=['bar'],
                           codebases=[IntParameter('foo')])

        # codebases cannot be empty
        with self.assertRaisesConfigError(
                "ForceScheduler 'foo': 'codebases' cannot be "
                "empty; use [CodebaseParameter(codebase='', hide=True)] if needed:"):
            ForceScheduler(name='foo', builderNames=['bar'], codebases=[])

        # codebases cannot be a dictionary
        # dictType on Python 3 is: "<class 'dict'>"
        # dictType on Python 2 is: "<type 'dict'>"
        dictType = str(type({}))
        errMsg = ("ForceScheduler 'foo': 'codebases' should be a list "
                  "of strings or CodebaseParameter, "
                  "not {}".format(dictType))
        with self.assertRaisesConfigError(errMsg):
            ForceScheduler(name='foo', builderNames=['bar'],
                           codebases={'cb': {'branch': 'trunk'}})
Exemple #4
0
 def test_NestedParameter(self):
     fields = [
         IntParameter(name="foo")
     ]
     self.do_ParameterTest(req=dict(p1_foo='123', reason="because"),
                           expect=dict(foo=123),
                           klass=NestedParameter, fields=fields)
Exemple #5
0
    def test_bad_codebases(self):
        # cant specify both codebases and branch/revision/project/repository:
        self.assertRaisesConfigError("ForceScheduler: Must either specify 'codebases' or the 'branch/revision/repository/project' parameters:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=['foo'], branch=StringParameter('name')))
        self.assertRaisesConfigError("ForceScheduler: Must either specify 'codebases' or the 'branch/revision/repository/project' parameters:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=['foo'], revision=StringParameter('name')))
        self.assertRaisesConfigError("ForceScheduler: Must either specify 'codebases' or the 'branch/revision/repository/project' parameters:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=['foo'], project=StringParameter('name')))
        self.assertRaisesConfigError("ForceScheduler: Must either specify 'codebases' or the 'branch/revision/repository/project' parameters:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=['foo'], repository=StringParameter('name')))

        # codebases must be a list of either string or BaseParameter types
        self.assertRaisesConfigError("ForceScheduler: 'codebases' must be a list of strings or CodebaseParameter objects:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=[123],))
        self.assertRaisesConfigError("ForceScheduler: 'codebases' must be a list of strings or CodebaseParameter objects:",
             lambda: ForceScheduler(name='foo', builderNames=['bar'],
                                    codebases=[IntParameter('foo')],))

        # codebases cannot be empty
        self.assertRaisesConfigError("ForceScheduler: 'codebases' cannot be empty; use CodebaseParameter(codebase='', hide=True) if needed:",
                                     lambda: ForceScheduler(name='foo',
                                                            builderNames=['bar'],
                                                            codebases=[]))
 def test_NestedParameter(self):
     fields = [
         IntParameter(name="foo")
     ]
     self.do_ParameterTest(req=dict(p1_foo='123', reason="because"),
                           expect=dict(foo=123),
                           klass=NestedParameter, fields=fields,
                           expectJson='{"name": "p1", "fullName": "p1", "label": "p1", "autopopulate": null, '
                           '"tablabel": "p1", "type": "nested", "default": "", "required": false, '
                           '"multiple": false, "regex": null, "hide": false, "maxsize": null, '
                           '"layout": "vertical", "columns": 1, "fields": [{"name": "foo", '
                           '"fullName": "p1_foo", "label": "foo", "tablabel": "foo", "autopopulate": null, '
                           '"type": "int", "default": 0, "required": false, "multiple": false, '
                           '"regex": null, "hide": false, "maxsize": null, "size": 10}]}')
    def test_bad_codebases(self):
        # cant specify both codebases and branch/revision/project/repository:
        self.assertRaises(ValidationError,
                          ForceScheduler,
                          name='foo',
                          builderNames=['bar'],
                          codebases=['foo'],
                          branch=StringParameter('name'))
        self.assertRaises(ValidationError,
                          ForceScheduler,
                          name='foo',
                          builderNames=['bar'],
                          codebases=['foo'],
                          revision=StringParameter('name'))
        self.assertRaises(ValidationError,
                          ForceScheduler,
                          name='foo',
                          builderNames=['bar'],
                          codebases=['foo'],
                          project=StringParameter('name'))
        self.assertRaises(ValidationError,
                          ForceScheduler,
                          name='foo',
                          builderNames=['bar'],
                          codebases=['foo'],
                          repository=StringParameter('name'))

        # codebases must be a list of either string or BaseParameter types
        self.assertRaises(
            ValidationError,
            ForceScheduler,
            name='foo',
            builderNames=['bar'],
            codebases=[123],
        )
        self.assertRaises(
            ValidationError,
            ForceScheduler,
            name='foo',
            builderNames=['bar'],
            codebases=[IntParameter('foo')],
        )

        # codebases cannot be empty
        self.assertRaises(ValidationError,
                          ForceScheduler,
                          name='foo',
                          builderNames=['bar'],
                          codebases=[])
Exemple #8
0
 def test_NestedNestedParameter(self):
     fields = [
         NestedParameter(name="inner", fields=[
             StringParameter(name='str'),
             AnyPropertyParameter(name='any')
         ]),
         IntParameter(name="foo")
     ]
     self.do_ParameterTest(req=dict(p1_foo='123',
                                    p1_inner_str="bar",
                                    p1_inner_any_name="hello",
                                    p1_inner_any_value="world",
                                    reason="because"),
                           expect=dict(foo=123, inner=dict(str="bar", hello="world")),
                           klass=NestedParameter, fields=fields)
    def test_bad_codebases(self):

        # codebases must be a list of either string or BaseParameter types
        self.assertRaisesConfigError(
            "ForceScheduler: 'codebases' must be a list of strings or CodebaseParameter objects:",
            lambda: ForceScheduler(
                name='foo',
                builderNames=['bar'],
                codebases=[123],
            ))
        self.assertRaisesConfigError(
            "ForceScheduler: 'codebases' must be a list of strings or CodebaseParameter objects:",
            lambda: ForceScheduler(
                name='foo',
                builderNames=['bar'],
                codebases=[IntParameter('foo')],
            ))

        # codebases cannot be empty
        self.assertRaisesConfigError(
            "ForceScheduler: 'codebases' cannot be empty; use CodebaseParameter(codebase='', hide=True) if needed:",
            lambda: ForceScheduler(
                name='foo', builderNames=['bar'], codebases=[]))