Python DefaultChecker.getArg方法代码示例

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def test_solvingParams10(self):
        @shellMethod(
            param1=ListArgChecker(
                DefaultChecker.getArg(),
                maximum_size=3))
        def tutu(param1):
            pass

        m = UniCommand(tutu)
        self.mltries.insert(("tutu",), m)

        p = Parser("tutu -param1 1 2")
        p.parse()
        s = Solver()
        solvingresult = s.solve(p, self.mltries, self.var)
        commandList, argList, mappedArgsList, commandNameList = solvingresult

        assert len(commandNameList) == 1
        assert commandNameList[0] == ("tutu",)

        assert len(commandList) == 1
        assert commandList[0] == self.mltries.search(("tutu",)).getValue()

        assert len(mappedArgsList) == 1
        assert len(mappedArgsList[0][0]) == 1
        assert len(mappedArgsList[0][1]) == 0
        assert len(mappedArgsList[0][2]) == 0

        assert "param1" in mappedArgsList[0][0]
        assert mappedArgsList[0][0]["param1"] == ("1", "2",)

        assert len(argList[0]) == 0

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def test_setValuesNotOnListParameter(self):
        createValues(value_type=None,
                     key="set_values",
                     values=("toto", "titi", "tata"),
                     manager=self.env,
                     list_enabled=False,
                     local_param=True,)

        setValues(key="set_values",
                  values=("tutu", "tyty",),
                  manager=self.env,
                  start_with_local=True,
                  explore_other_scope=False)

        assert self.env.hasParameter("set_values",
                                     perfect_match=True,
                                     local_param=True,
                                     explore_other_scope=False)
        param = self.env.getParameter(string_path="set_values",
                                      perfect_match=True,
                                      local_param=True,
                                      explore_other_scope=False)

        assert param.getValue() == "tutu"
        assert not isinstance(param.settings.getChecker(), ListArgChecker)
        assert param.settings.getChecker() is DefaultChecker.getArg()

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
 def test_createValuesNoListWithEmptyValue(self):
     with pytest.raises(Exception):
         createValues(value_type=DefaultChecker.getArg(),
                      key="creates_value",
                      values=(),
                      manager=self.env,
                      list_enabled=False,
                      local_param=True,)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def setup_method(self, method):
        settings = EnvironmentGlobalSettings(transient=True,
                                             read_only=True,
                                             removable=False,
                                             checker=DefaultChecker.getArg())

        self.mltries = multiLevelTries()
        self.mlparam = EnvironmentParameter(value=self.mltries,
                                            settings=settings)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
 def test_getPropertiesNoGetter(self):
     info = "setToto", "getToto", DefaultChecker.getArg()
     with pytest.raises(Exception):
         getProperties(key="local",
                       property_info=info,
                       manager=self.env,
                       start_with_local=True,
                       explore_other_scope=False,
                       perfect_match=True)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def testSimpleOneWithMultiOutput(self):
        @shellMethod(arg1=IntegerArgChecker())
        def pre(arg1=0):
            self.pre_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            return MultiOutput([5 + arg1, 10 + arg1])

        @shellMethod(arg2=DefaultChecker.getInteger())
        def pro(arg2):
            self.pro_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            return MultiOutput([arg2 * arg2, arg2 * arg2 * arg2])

        @shellMethod(arg3=DefaultChecker.getArg())
        def post(arg3):
            # print arg3
            assert arg3 in self.valueToTest
            self.post_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            return MultiOutput([arg3, arg3])

        # simple test
        self.valueToTest = [25, 125, 100, 1000]
        self.pre_count = self.pro_count = self.post_count = 0
        uc = UniCommand(pre, pro, post)
        self.engine = EngineV3([uc], [[]], [[{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 1
        assert self.pro_count == 2
        assert self.post_count == 4

        self.valueToTest = [100, 1000, 225, 3375, 400, 8000]
        self.pre_count = self.pro_count = self.post_count = 0
        # uni command encapsulation test, the most used case
        self.engine = EngineV3([uc, uc], [[], []], [
                               [{}, {}, {}], [{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 3
        assert self.pro_count == 4
        assert self.post_count == 24

        self.valueToTest = [225, 3375, 400, 8000, 625, 15625, 900, 27000]
        self.pre_count = self.pro_count = self.post_count = 0
        self.engine = EngineV3([uc, uc, uc],
                               [[], [], []],
                               [[{}, {}, {}], [{}, {}, {}], [{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 7
        assert self.pro_count == 8
        assert self.post_count == 112

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def testExecuteSimpleOne(self):
        @shellMethod(arg1=IntegerArgChecker())
        def pre(arg1=0):
            self.pre_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            return 5 + arg1

        @shellMethod(arg2=DefaultChecker.getInteger())
        def pro(arg2):
            self.pro_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            return arg2 * arg2

        @shellMethod(arg3=DefaultChecker.getArg())
        def post(arg3):
            assert arg3 == self.valueToTest
            self.post_count += 1
            self.checkStack(self.engine.stack, self.engine.cmd_list)
            # needed to the next post method in case of encapsulation
            return arg3

        # simple test
        self.valueToTest = 25
        self.pre_count = self.pro_count = self.post_count = 0
        uc = UniCommand(pre, pro, post)
        self.engine = EngineV3([uc], [[]], [[{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 1
        assert self.pro_count == 1
        assert self.post_count == 1

        self.valueToTest = 100
        self.pre_count = self.pro_count = self.post_count = 0
        # uni command encapsulation test, the most used case
        self.engine = EngineV3([uc, uc], [[], []], [
                               [{}, {}, {}], [{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 2
        assert self.pro_count == 1
        assert self.post_count == 2

        self.valueToTest = 225
        self.pre_count = self.pro_count = self.post_count = 0
        self.engine = EngineV3([uc, uc, uc],
                               [[], [], []],
                               [[{}, {}, {}], [{}, {}, {}], [{}, {}, {}]])
        self.engine.execute()
        assert self.pre_count == 3
        assert self.pro_count == 1
        assert self.post_count == 3

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def decorator(fun):
        # inspect the function AND insure fun hold a function
        analyzed_fun = FunAnalyser(fun)

        # is there already a decorator ?
        if hasattr(fun, "checker"):
            excmsg = ("(shellMethod) the function '%s' has already a "
                      "shellMethod decorator")
            excmsg %= fun.__name__
            raise DecoratorException(excmsg)

        arg_checker_list = OrderedDict()
        for i in range(0, len(analyzed_fun.inspect_result.args)):
            # for argname in analyzed_fun.inspect_result.args:
            argname = analyzed_fun.inspect_result.args[i]

            # don't care about the self arg, the python framework will
            # manage it
            if i == 0 and argname == "self" and type(fun) != staticMethType:
                # http://stackoverflow.com/questions/8793233/
                frames = inspect.stack()
                if (len(frames) > 2 and
                   frames[2][4][0].strip().startswith('class ')):
                    continue

            if argname in arg_list:  # check if the argname is in the arg_list
                checker = arg_list[argname]
                del arg_list[argname]
                checker = analyzed_fun.setCheckerDefault(argname, checker)
                arg_checker_list[argname] = checker

            # check if the arg has a DEFAULT value
            elif analyzed_fun.hasDefault(argname):
                checker = DefaultValueChecker(analyzed_fun.getDefault(argname))
                arg_checker_list[argname] = checker
            else:
                arg_checker_list[argname] = DefaultChecker.getArg()

        # All the key are used in the function call?
        keys = arg_list.keys()
        if len(keys) > 0:
            string = ",".join(arg_list.keys())
            excmsg = ("(shellMethod) the following key(s) have no match in the"
                      " '%s' function prototype : '%s'")
            excmsg %= (fun.__name__, string,)
            raise DecoratorException(excmsg)

        # set the checker on the function
        fun.checker = ArgFeeder(arg_checker_list)
        return fun

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def setup_method(self, method):
        self.params = ParentManager()

        # set command tries environment
        self.mltries = multiLevelTries()
        settings = EnvironmentGlobalSettings(transient=True,
                                             read_only=True,
                                             removable=False,
                                             checker=DefaultChecker.getArg())

        self.params.getEnvironmentManager().setParameter(
            ENVIRONMENT_LEVEL_TRIES_KEY,
            EnvironmentParameter(value=self.mltries, settings=settings),
            local_param=True)

        root_profile = RootProfile()
        self.profile = CommandLoader.createProfileInstance(root_profile)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
 def test_createValueNoType(self):
     createValue(value_type=None,
                 key="create_value",
                 value="titi",
                 manager=self.env,
                 local_param=True,)
     assert self.env.hasParameter("create_value",
                                  perfect_match=True,
                                  local_param=True,
                                  explore_other_scope=False)
     param = self.env.getParameter(string_path="create_value",
                                   perfect_match=True,
                                   local_param=True,
                                   explore_other_scope=False)
     assert param.getValue() == "titi"
     assert not isinstance(param.settings.getChecker(), ListArgChecker)
     assert param.settings.getChecker() is DefaultChecker.getArg()

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def test_limitReaching(self):
        @shellMethod(arg1=IntegerArgChecker())
        def pre(arg1=0):
            self.pre_count += 1
            return 5 + arg1

        @shellMethod(arg2=DefaultChecker.getInteger())
        def pro(arg2):
            self.pro_count += 1
            return arg2 * arg2

        @shellMethod(arg3=DefaultChecker.getArg())
        def post(arg3):
            self.post_count += 1
            # needed to the next post method in case of encapsulation
            return arg3

        # simple test
        self.valueToTest = 25
        self.pre_count = self.pro_count = self.post_count = 0
        uc = UniCommand(pre, pro, post)

        # set a large amount of data for the pre, then the pro, then the post
        engine = EngineV3([uc], [[]], [[{}, {}, {}]])
        engine.stack[0] = ([5] * (DEFAULT_EXECUTION_LIMIT + 1), [0], 0, None)
        with pytest.raises(ExecutionException):
            engine.execute()
        assert uc[0][0].pre_count == 256
        assert uc[0][0].pro_count == 255
        assert uc[0][0].post_count == 255

        engine = EngineV3([uc], [[]], [[{}, {}, {}]])
        engine.stack[0] = ([5] * (DEFAULT_EXECUTION_LIMIT + 1), [0], 1, None)
        with pytest.raises(ExecutionException):
            engine.execute()
        assert uc[0][0].pre_count == 0
        assert uc[0][0].pro_count == 256
        assert uc[0][0].post_count == 255

        engine = EngineV3([uc], [[]], [[{}, {}, {}]])
        engine.stack[0] = ([5] * (DEFAULT_EXECUTION_LIMIT + 1), [0], 2, None)
        with pytest.raises(ExecutionException):
            engine.execute()
        assert uc[0][0].pre_count == 0
        assert uc[0][0].pro_count == 0
        assert uc[0][0].post_count == 256

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
 def test_createValuesListNoTypeSuccess(self):
     createValues(value_type=None,
                  key="creates_value",
                  values=(11, 22, 33,),
                  manager=self.env,
                  list_enabled=True,
                  local_param=True,)
     assert self.env.hasParameter("creates_value",
                                  perfect_match=True,
                                  local_param=True,
                                  explore_other_scope=False)
     param = self.env.getParameter(string_path="creates_value",
                                   perfect_match=True,
                                   local_param=True,
                                   explore_other_scope=False)
     assert param.getValue() == [11, 22, 33]
     assert isinstance(param.settings.getChecker(), ListArgChecker)
     assert param.settings.getChecker().checker is DefaultChecker.getArg()

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
def createValue(key,
                value,
                value_type=DefaultChecker.getArg().getTypeName(),
                manager=None,
                local_param=True):
    """create an environment parameter value"""
    if value_type is not None:
        origin_checker = "%s %s" % (manager.getLoaderName().title(), key,)
        value = value_type.getValue(value, None, origin_checker)

    param = manager.setParameter(string_path=key,
                                 param=value,
                                 local_param=local_param)
    if value_type is not None:
        # XXX see explanations in createValues
        param.settings.setChecker(value_type)

    param.settings.setListChecker(False)
    param.setValue(value)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
def createValues(key,
                 values,
                 value_type=DefaultChecker.getArg().getTypeName(),
                 manager=None,
                 list_enabled=True,
                 local_param=True,
                 min_size=0):
    """create an environment parameter value"""

    if not list_enabled:
        if len(values) == 0:
            excmsg = "No value provided for the parameter '%s'"
            excmsg %= key
            raise Exception(excmsg)

        values = values[0]

    if value_type is not None:
        if list_enabled:
            value_type = ListArgChecker(value_type, min_size)

        origin_checker = "%s %s" % (manager.getLoaderName().title(), key,)
        values = value_type.getValue(values, None, origin_checker)

    param = manager.setParameter(string_path=key,
                                 param=values,
                                 local_param=local_param)
    if value_type is not None:
        # XXX if a different checker from the default one is used, the value
        #   need to be rechecked, because it is not checker in the setChecker
        #   method of settings, settings does not have access to the parameter
        #   value to check them
        param.settings.setChecker(value_type)

    if not list_enabled:
        param.settings.setListChecker(list_enabled)

    if value_type is not None or not list_enabled:
        param.setValue(values)

# 需要导入模块: from pyshell.arg.checker.default import DefaultChecker [as 别名]
# 或者: from pyshell.arg.checker.default.DefaultChecker import getArg [as 别名]
    def test_setValuesOnListParameter(self):
        createValues(value_type=None,
                     key="set_values",
                     values=(11, 22, 33,),
                     manager=self.env,
                     list_enabled=True,
                     local_param=True,)
        setValues(key="set_values",
                  values=(44, 55, 66,),
                  manager=self.env,
                  start_with_local=True,
                  explore_other_scope=False)

        assert self.env.hasParameter("set_values",
                                     perfect_match=True,
                                     local_param=True,
                                     explore_other_scope=False)
        param = self.env.getParameter(string_path="set_values",
                                      perfect_match=True,
                                      local_param=True,
                                      explore_other_scope=False)
        assert param.getValue() == [44, 55, 66]
        assert isinstance(param.settings.getChecker(), ListArgChecker)
        assert param.settings.getChecker().checker is DefaultChecker.getArg()