Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use _filter_secrets method in lisa

Best Python code snippet using lisa_python

objects.py

Source:objects.py

1# Copyright 2019 Katteli Inc.2# TestFlows.com Open-Source Software Testing Framework (http://testflows.com)3#4# Licensed under the Apache License, Version 2.0 (the "License");5# you may not use this file except in compliance with the License.6# You may obtain a copy of the License at7#8#      http://www.apache.org/licenses/LICENSE-2.09#10# Unless required by applicable law or agreed to in writing, software11# distributed under the License is distributed on an "AS IS" BASIS,12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13# See the License for the specific language governing permissions and14# limitations under the License.15import re16import base6417import hashlib18import threading19import testflows.settings as settings20from collections import namedtuple21from .utils.enum import IntEnum22from .exceptions import SpecificationError, RequirementError, ResultException23from .baseobject import TestObject, Table24from .baseobject import get, hash25from .testtype import TestType26import testflows._core.contrib.rsa as rsa27class Result(TestObject, ResultException):28    _fields = ("message", "reason", "type", "test")29    _defaults = (None,) * 630    metrics = []31    tickets = []32    values = []33    type = None34    class Type(IntEnum):35        OK = 136        Fail = 237        Error = 338        Null = 439        Skip = 540        XOK = 641        XFail = 742        XError = 843        XNull = 944        def __repr__(self):45            return f"Result.Type.{self._name_}"46    def __init__(self, message=None, reason=None, type=None, test=None, metrics=None, tickets=None, values=None, start_time=None, test_time=None):47        from .funcs import current48        self.test = test if test is not None else current().name49        if not isinstance(self.test, str):50            raise TypeError("test must be of 'str' type")51        self.type = get(type, self.type)52        if self.type is None:53            raise TypeError("type must be defined")54        self.message = message55        self.reason = reason56        self.metrics = get(metrics, list(self.metrics))57        self.tickets = get(tickets, list(self.tickets))58        self.values = get(values, list(self.values))59        self.start_time = start_time60        self.test_time = test_time61        return super(Result, self).__init__()62    def __reduce__(self):63        return (self.__class__, (self.message, self.reason, self.type, self.test, self.metrics, self.tickets, self.values, self.start_time, self.test_time))64    @property65    def value(self):66        return self.values[-1].value if self.values else None67    def __call__(self, result=None):68        if result is None:69            result = getattr(self.__module__, str(self.type))70        obj = result.__class__(*[getattr(result, field) for field in result._fields])71        obj.metrics = self.metrics72        obj.tickets = self.tickets73        obj.values = self.values74        obj.start_time = self.start_time75        obj.test_time = self.test_time76        return obj77    def xout(self, reason=None):78        if type(self) in [Result, XResult]:79            return self().xout(reason=reason)80        return self81    def __str__(self):82        return str(self.type)83    def __bool__(cls):84        return True85    def __eq__(self, o):86        return self.type == o.type87    def __ne__(self, o):88        return not self == o89class XResult(Result):90    pass91class OK(Result):92    type = Result.Type.OK93    def xout(self, reason):94        return self(XOK(test=self.test, message=self.message, reason=reason))95class XOK(XResult):96    type = Result.Type.XOK97class Fail(Result):98    type = Result.Type.Fail99    def xout(self, reason):100        return self(XFail(test=self.test, message=self.message, reason=reason))101    def __bool__(self):102        return False103class XFail(XResult):104    type = Result.Type.XFail105class Skip(Result):106    type = Result.Type.Skip107class Error(Result):108    type = Result.Type.Error109    def xout(self, reason):110        return self(XError(test=self.test, message=self.message, reason=reason))111    def __bool__(self):112        return False113class XError(XResult):114    type = Result.Type.XError115class Null(Result):116    type = Result.Type.Null117    def xout(self, reason):118        return self(XNull(test=self.test, message=self.message, reason=reason))119    def __bool__(self):120        return False121class XNull(XResult):122    type = Result.Type.XNull123XoutResults = (XOK, XFail, XError, XNull)124FailResults = (Fail, Error, Null)125PassResults = (OK,) + XoutResults126NonFailResults = (Skip,) + PassResults127class Node(TestObject):128    _fields = ("name", "module", "uid", "nexts", "ins", "outs")129    _defaults = (None,) * 3130    NodeAttributes = namedtuple("NodeAttributes", "name module uid")131    def __init__(self, name, module, uid, nexts=None, ins=None, outs=None):132        self.name = name133        self.module = module134        self.uid = uid135        self.nexts = get(nexts, [])136        self.ins = get(ins, [])137        self.outs =get(outs, [])138        return super(Node, self).__init__()139    @classmethod140    def attributes(cls, test):141        name = test.__name__142        module = ".".join([test.__module__, test.__name__])143        uid = hash(module, short=True)144        return cls.NodeAttributes(name, module, uid)145class Tag(TestObject):146    _fields = ("value",)147    _defaults = ()148    def __init__(self, value):149        self.value = value150        return super(Tag, self).__init__()151    def __str__(self):152        return str(self.value)153class Argument(TestObject):154    _fields = ("name", "value", "type", "group", "uid")155    _defaults = (None,) * 4156    uid = None157    type = None158    group = None159    def __init__(self, name, value=None, type=None, group=None, uid=None):160        self.name = name161        self.value = value162        self.type = get(type, self.type)163        self.group = get(group, self.group)164        self.uid = get(uid, self.uid)165        return super(Argument, self).__init__()166class Attribute(TestObject):167    _fields = ("name", "value", "type", "group", "uid")168    _defaults = (None,) * 3169    uid = None170    type = None171    group = None172    def __init__(self, name, value, type=None, group=None, uid=None):173        self.name = name174        self.value = value175        self.type = get(type, self.type)176        self.group = get(group, self.group)177        self.uid = get(uid, self.uid)178        return super(Attribute, self).__init__()179class Requirement(TestObject):180    _fields = ("name", "version", "description",181            "link", "priority", "type", "group", "uid", "level", "num")182    _defaults = (None,) * 8183    uid = None184    link = None185    priority = None186    type = None187    group = None188    def __init__(self, name, version, description=None, link=None,189            priority=None, type=None, group=None, uid=None, level=None, num=None):190        self.name = name191        self.version = version192        self.description = get(description, self.__doc__)193        self.link = get(link, self.link)194        self.priority = get(priority, self.priority)195        self.type = get(type, self.type)196        self.group = get(group, self.group)197        self.uid = get(uid, self.uid)198        self.level = level199        self.num = num200        return super(Requirement, self).__init__()201    def __call__(self, *version):202        if not self.version in version:203            raise RequirementError("requirement version %s is not in %s" % (self.version, list(version)))204        return self205class Metric(TestObject):206    _fields = ("name", "value", "units", "type", "group", "uid")207    _defaults = (None,) * 3208    uid = None209    type = None210    group = None211    def __init__(self, name, value, units, type=None, group=None, uid=None):212        self.name = name213        self.value = value214        self.units = units215        self.type = get(type, self.type)216        self.group = get(group, self.group)217        self.uid = get(uid, self.uid)218        return super(Metric, self).__init__()219class Value(TestObject):220    _fields = ("name", "value", "type", "group", "uid")221    _defaults = (None,) * 3222    uid = None223    type = None224    group = None225    def __init__(self, name, value, type=None, group=None, uid=None):226        self.name = name227        self.value = str(value)228        self.type = get(type, self.type)229        self.group = get(group, self.group)230        self.uid = get(uid, self.uid)231        return super(Value, self).__init__()232class Ticket(TestObject):233    _fields = ("name", "link", "type", "group", "uid")234    _defaults = (None,) * 4235    uid = None236    link = None237    type = None238    group = None239    def __init__(self, name, link=None, type=None, group=None, uid=None):240        self.name = name241        self.link = get(link, self.link)242        self.type = get(type, self.type)243        self.group = get(group, self.group)244        self.uid = get(uid, self.uid)245        return super(Ticket, self).__init__()246class Specification(TestObject):247    _fields = ("name", "content", "description", "link", "author", "version",248        "date", "status", "approved_by", "approved_date", "approved_version",249        "type", "group", "uid", "parent", "children", "headings", "requirements")250    _defaults = (None,) * 16251    uid = None252    link = None253    type = None254    group = None255    Heading = namedtuple("Heading", "name level num")256    def __init__(self, name, content, description=None, link=None, author=None, version=None,257        date=None, status=None, approved_by=None, approved_date=None, approved_version=None,258        type=None, group=None, uid=None, parent=None, children=None, headings=None,259        requirements=None):260        self.name = name261        self.content = content262        self.description = description263        self.author = author264        self.version = version265        self.date = date266        self.status = status267        self.approved_by = approved_by268        self.approved_date = approved_date269        self.approved_version = approved_version270        self.link = get(link, self.link)271        self.type = get(type, self.type)272        self.group = get(group, self.group)273        self.uid = get(uid, self.uid)274        self.parent = parent275        self.children = children276        self.headings = headings277        self.requirements = requirements278    def __call__(self, *version):279        if not self.version in version:280            raise SpecificationError("specification version %s is not in %s" % (self.version, list(version)))281        return self282class ExamplesRow(TestObject):283    _fields = ("row", "columns", "values", "row_format")284    _defaults = (None,)285    def __init__(self, row, columns, values, row_format=None):286        self.row = row287        self.columns = columns288        self.values = [str(value) for value in values]289        self.row_format = row_format290class Secrets:291    """Secrets registry.292    """293    def __init__(self, secrets=None):294        self._secrets = secrets or {}295        self._filter_regex = re.compile(r"")296        self._filter_secrets = []297        self._lock = threading.Lock()298        self._update_filter()299    300    def __reduce__(self):301        return (Secrets, (self._secrets,))302    def is_empty(self):303        """Return True if registry is empty.304        """305        with self._lock:306            return not bool(self._filter_secrets)307    def register(self, secret):308        """Register secret object.309        """310        with self._lock:311            if secret.name in self._secrets:312                raise ValueError(f"secret '{secret.name}' already registered")313            self._secrets[secret.name] = secret314            self._update_filter()315    def unregister(self, secret):316        """Unregister secret object.317        """318        with self._lock:319            self._secrets.pop(secret.name, None)320            self._update_filter()321    def _update_filter(self):322        """Update filter regex.323        """324        self._filter_secrets = [s for s in self._secrets.values() if s.is_set()]325        self._filter_regex = re.compile("|".join([f"(?P<{s.name}>{re.escape(s.value)})" for s in self._filter_secrets]))326    def filter(self, message):327        """Filter all secret values from message.328        """329        def _filter(s):330            if not isinstance(s, str):331                return message332            return self._filter_regex.sub(lambda m: f"[masked]:{self._filter_secrets[m.lastindex-1]}", s)333    334        with self._lock:335            if isinstance(message, (list, tuple)):336                for i, e in enumerate(message):337                    message[i] = self.filter(e)338                return message339            elif isinstance(message, dict):340                _message = {}341                for k, v in message.items():342                    _message[filter(k)] = filter(v)343                return _message344            return _filter(message)345class Secret(TestObject):346    """Secret value.347    """348    _fields = ("name", "type", "group", "uid")349    _defaults = (None,) * 4350    351    uid = None352    type = None353    name = None354    group = None355    def __init__(self, name=None, type=None, group=None, uid=None):356        self.name = get(name, self.name)357        if self.name is None:358            raise TypeError("name must be specified")359        else:360            try:361                re.compile(rf"(?P<{self.name}>)")362            except re.error as e:363                raise ValueError("invalid secret name, " + str(e).replace("group name ", "")) from None364        self.type = get(type, self.type)365        self.group = get(group, self.group)366        self.uid = get(uid, self.uid)367        self._value = None368    def __enter__(self):369        return self370    371    def __exit__(self, exc_value, exc_type, exc_tb):372        self.clear()373    def clear(self):374        self._value = None375        if not settings.secrets_registry:376            raise RuntimeError("no secrets registry")377        settings.secrets_registry.unregister(self)378        return self379    def __call__(self, value=None):380        if value is not None:381            self._value = str(value)382            if not settings.secrets_registry:383                raise RuntimeError("no secrets registry")384            settings.secrets_registry.register(self)385        return self386    def is_set(self):387        """Return true if value has been set.388        """389        return self._value is not None390    @property391    def value(self):392        """Return plaintext value of the secret.393        """394        if self._value is None:395            raise ValueError("no value")396        return self._value397    def __str__(self):398        return self.__repr__()399    def __repr__(self):400        """Custom object representation.401        """402        kwargs = []403        for field in self._fields:404            value = getattr(self, field)405            if value is None:406                continue407            kwargs.append(f"{field}={repr(value)}")408        return f"Secret({','.join(kwargs)})"409class RSASecret(Secret):410    """RSA encrypted secret value.411    """412    _fields = ("name", "type", "group", "uid", "code", "pubkey_id",)413    _defaults = (None,) * 6414    uid = None415    name = None416    type = None417    group = None418    encoding = "utf-8"419    def __init__(self, name=None, type=None, group=None, uid=None, code=None, pubkey_id=None):420        self.name = get(name, None)421        self.type = get(type, self.type)422        self.group = get(group, self.group)423        self.uid = get(uid, self.uid)424        self.pubkey_id = get(pubkey_id, None)425        if self.pubkey_id is not None:426            self.pubkey_id = base64.b64decode(pubkey_id.encode(self.encoding))427        self.code = get(code, None)428        self._value = None429        self.__call__(code=code)430    def __call__(self, value=None, code=None, private_key=None, public_key=None):431        if value is not None:432            self._value = str(value)433            self.code = None434        if code is not None:435            self.code = base64.b64decode(code.encode(self.encoding))436            self._value = None437        if public_key is not None:438            self.pubkey_id = hashlib.sha1(public_key.save_pkcs1()).digest()439            self.code = None440            if self._value is None:441                raise ValueError("no value")442            self.code = rsa.encrypt(self._value.encode(self.encoding), public_key)443        if private_key is not None:444            if self.pubkey_id is not None:445                pk_id = hashlib.sha1(private_key.pubkey.save_pkcs1()).digest()446                if self.pubkey_id != pk_id:447                    raise ValueError("wrong private key")448            if self.code is None:449                raise ValueError("no code")450            self._value = rsa.decrypt(self.code, private_key).decode(self.encoding)451        return self452    def __repr__(self):453        """Custom object representation.454        """455        kwargs = []456        for field in self._fields:457            value = getattr(self, field)458            if value is None:459                continue460            if field in ("code", "pubkey_id"):461                kwargs.append(f"{field}='{base64.b64encode(value).decode('utf-8')}'")462            else:463                kwargs.append(f"{field}={repr(value)}")464        return f"Secret({','.join(kwargs)})"465class ExamplesTable(Table):466    _row_type_name = "Example"467    def __new__(cls, header=None, rows=None, row_format=None, args=None):468        if rows is None:469            rows = []470        if header is None:471            header = ""472        if args is None:473            args = {}474        else:475            args = dict(args)476        row_type = namedtuple(cls._row_type_name, header)477        class ExampleRow(row_type):478            def __new__(cls, *args):479                _args = {}480                args = list(args)481                len_header = len(header.split(" "))482                if len(args) > len_header:483                    _args = {k:v for arg in args[len_header:] for k, v in dict(arg).items()}484                    if "type" in args:485                        raise TypeError("can't specify 'type' using example arguments")486                    if "args" in args:487                        raise TypeError("can't specify 'args' using example arguments")488                    del args[len_header:]489                obj = super(ExampleRow, cls).__new__(cls, *args)490                obj._args = _args491                return obj492        obj = super(ExamplesTable, cls).__new__(cls, header, rows, row_format, ExampleRow)493        for idx, row in enumerate(obj):494            row._idx = idx495            row._row_format = obj.row_format496        obj.args = args497        return obj498class NamedValue(object):499    name = None500    def __init__(self, value):501        self.value = value502    def keys(self):503        return [self.name]504    def __getitem__(self, key):505        if key == self.name:506            return self.value507        raise KeyError(key)508    def __call__(self, func):509        setattr(func, self.name, self.value)510        return func511class NamedString(NamedValue):512    def __str__(self):513        return str(self.value)514class NamedList(list):515    name = None516    def __init__(self, *items):517        super(NamedList, self).__init__(items)518    def keys(self):519        return [self.name]520    def __getitem__(self, key):521        if key == self.name:522            return list(self)523        return super(NamedList, self).__getitem__(key)524    def __call__(self, func):525        setattr(func, self.name, list(self))526        return func527class Onlys(NamedList):528    """only container.529    ```python530    @Only(531        pattern,532        ...533    )534    ```535    """536    name = "only"537    def __init__(self, *items):538        super(Onlys, self).__init__(*items)539class Skips(NamedList):540    """skip container.541    ```python542    @Skips(543        pattern,544        ...545    )546    ```547    """548    name = "skip"549    def __init__(self, *items):550        super(Skips, self).__init__(*items)551class _FilterTags(NamedValue):552    """filter tags object.553    """554    def __init__(self, test=None, suite=None, module=None, any=None):555        test = set(test) if test is not None else set()556        suite = set(suite) if suite is not None else set()557        module = set(module) if module is not None else set()558        any = set(any) if any is not None else set()559        if any:560            test = test.union(any)561            suite = suite.union(any)562            module = module.union(any)563        super(_FilterTags, self).__init__({TestType.Test: test, TestType.Suite: suite, TestType.Module: module})564class OnlyTags(_FilterTags):565    """only_tags filter object.566    ```python567    @OnlyTags(568       test=[tagA,(tagA,tagB),...],569       suite=[...],570       module=[...],571       any=[...]572    )573    ```574    """575    name = "only_tags"576class SkipTags(_FilterTags):577    """skip_tags filter object.578    ```python579    @SkipTags(580       test=[tagA,(tagA,tagB),...],581       suite=[...],582       module=[...],583       any=[...]584    )585    ```586    """587    name = "skip_tags"588class Setup(NamedValue):589    name = "setup"590class XFails(NamedValue):591    """xfails container.592    xfails = {593        "pattern": [("result", "reason"[, when])],594        ...595        }596    """597    name = "xfails"598    def __init__(self, value):599        super(XFails, self).__init__(dict(value))600    def items(self):601        return self.value.items()602    def add(self, pattern, *results):603        """Add an entry to the xfails.604        :param pattern: test name pattern to match605        :param *results: one or more results to cross out606            where each result is a two-tuple or three-tuple of (result, reason[, when])607        """608        self.value[pattern] = results609        return self610class FFails(NamedValue):611    """ffails (forced fails) container.612    ffails = {613        "pattern": (result, "reason"[, when]),614        ...615        }616    """617    name = "ffails"618    def __init__(self, value):619        value = dict(value)620        value = {p: list(FFail(*v).value.values())[0] for p, v in value.items()}621        super(FFails, self).__init__(value)622    def items(self):623        return self.value.items()624    def add(self, pattern, reason, result=Fail, when=None):625        """Add an entry to the ffails (force fails).626        :param pattern: test name pattern to match627        :param reason: reason628        :param result: forced result, default: Fails629        :param when: when filter630        """631        if when is not None and not callable(when):632            raise TypeError(f"invalid when type '{type(when)}'; must be callable")633        self.value[pattern] = (result, reason, when)634        return self635class FFail(NamedValue):636    """ffails (forced fails) container with single result.637    """638    name = "ffails"639    def __init__(self, result, reason, when=None, pattern=""):640        if not issubclass(result, Result):641            raise TypeError(f"invalid result '{result}' type")642        if not type(reason) in (str,):643            raise TypeError(f"reason '{type(reason)}' must be str")644        if when is not None and not callable(when):645            raise TypeError(f"when '{type(when)}' must be callable")646        647        super(FFail, self).__init__({pattern: (result, reason, when)})648class Skipped(FFail):649    """ffails (forced fails) container with single Skip result.650    """651    def __init__(self, reason, when=None, pattern=""):652        super(Skipped, self).__init__(reason=reason, when=when, pattern=pattern, result=Skip)653class Failed(FFail):654    """ffails (forced fails) container with single Fail result.655    """656    def __init__(self, reason, when=None, pattern=""):657        super(Failed, self).__init__(reason=reason, when=when, pattern=pattern, result=Fail)658class XFailed(FFail):659    """ffails (forced fails) container with single XFail result.660    """661    def __init__(self, reason, when=None, pattern=""):662        super(XFailed, self).__init__(reason=reason, when=when, pattern=pattern, result=XFail)663class XErrored(FFail):664    """ffails (forced fails) container with single XError result.665    """666    def __init__(self, reason, when=None, pattern=""):667        super(XErrored, self).__init__(reason=reason, when=when, pattern=pattern, result=XError)668class Okayed(FFail):669    """ffails (forced fails) container with single OK result.670    """671    def __init__(self, reason, when=None, pattern=""):672        super(Okayed, self).__init__(reason=reason, when=when, pattern=pattern, result=OK)673class XOkayed(FFail):674    """ffails (forced fails) container with single XOK result.675    """676    def __init__(self, reason, when=None, pattern=""):677        super(XOkayed, self).__init__(reason=reason, when=when, pattern=pattern, result=XOK)678class XFlags(NamedValue):679    """xflags container.680    xflags = {681        "filter": (set_flags, clear_flags[, when]),682        ...683    }684    """685    name = "xflags"686    def __init__(self, value):687        super(XFlags, self).__init__(dict(value))688    def items(self):689        return self.value.items()690    def add(self, pattern, set_flags=0, clear_flags=0, when=None):691        """Add an entry to the xflags.692        :param pattern: test name pattern to match693        :param set_flags: flags to set694        :param clear_flags: flags to clear, default: None695        :param when: condition function, default: None696        """697        self.value[pattern] = [Flags(set_flags), Flags(clear_flags), when]698        return self699class Repeats(NamedValue):700    """repeats containers.701    repeats={702        "pattern": (count, until),703        ...704    }705    """706    name = "repeats"707    def __init__(self, value):708        super(Repeats, self).__init__(dict(value))709class Repeat(NamedValue):710    """single repetition container.711    """712    name = "repeats"713    def __init__(self, count, until="complete", pattern=""):714        self.count = int(count)715        self.pattern = str(pattern)716        self.until = str(until)717        if self.count < 1:718            raise ValueError("count must be > 0")719        if self.until not in ("fail", "pass", "complete"):720            raise ValueError("invalid until value")721        return super(Repeat, self).__init__({self.pattern: (self.count, self.until)})722class Retries(NamedValue):723    """retries containers.724    retries={725        "pattern": count[,timeout[,delay[,backoff[,jitter]]]] ,726        ...727    }728    """729    name = "retries"730    def __init__(self, value):731        value = dict(value)732        value = {p: list(Retry(*r).value.values())[0] for p, r in value.items()}733        super(Retries, self).__init__(value)734class Retry(NamedValue):735    """single retry container.736    """737    name = "retries"738    def __init__(self, count=None, timeout=None, delay=0, backoff=1, jitter=None, pattern=""):739        """740        :param count: number of retries, default: None741        :param timeout: timeout in sec, default: None742        :param delay: delay in sec between retries, default: 0 sec743        :param backoff: backoff multiplier that is applied to the delay, default: 1744        :param jitter: jitter added to delay between retries specified as745                   a tuple(min, max), default: (0,0)746        """747        self.count = int(count) if count is not None else None748        self.timeout = float(timeout) if timeout is not None else None749        self.delay = float(delay)750        self.backoff = backoff751        self.jitter = tuple(jitter) if jitter else tuple([0, 0])752        753        self.pattern = str(pattern)754        if self.count is not None and self.count < 1:755            raise ValueError("count must be > 0")756        if self.timeout is not None and self.timeout < 0:757            raise ValueError("timeout must be >= 0")758        return super(Retry, self).__init__({self.pattern: (self.count, self.timeout, self.delay, self.backoff, self.jitter)})759class Args(dict):760    def __init__(self, **args):761        super(Args, self).__init__(**args)762    def __call__(self, func):763        for k, v in self.items():764            if not k.startswith("_"):765                setattr(func, k, v)766        return func767class Attributes(NamedList):768    name = "attributes"769    def __init__(self, *attributes):770        super(Attributes, self).__init__(*[Attribute(*a) for a in attributes])771class Requirements(NamedList):772    name = "requirements"773    def __init__(self, *requirements):774        super(Requirements, self).__init__(*[Requirement(*r) for r in requirements])775class Specifications(NamedList):776    name = "specifications"777    def __init__(self, *specifications):778        super(Specifications, self).__init__(*[Specification(*r) for r in specifications])779class Tags(NamedList):780    name = "tags"781    def __init__(self, *tags):782        super(Tags, self).__init__(*tags)783class Uid(NamedString):784    name = "uid"785class Parallel(NamedValue):786    name = "parallel"787    def __init__(self, value):788        self.value = bool(value)789class Executor(NamedValue):790    name = "executor"791    def __init__(self, executor):792        self.value = executor793class ArgumentParser(NamedValue):794    name = "argparser"795    def __init__(self, parser):796        self.value = parser797class Name(NamedString):798    name = "name"799class Description(NamedString):800    name = "description"801class Examples(ExamplesTable):802    def __new__(cls, header, rows, row_format=None, args=None):803        return super(Examples, cls).__new__(cls, header=header,804            rows=rows, row_format=row_format, args=args)805    def __call__(self, func):806        func.examples = self...

logger.py

Source:logger.py

...58    ) -> None:59        """60        Low-level log implementation, proxies to allow nested logger adapters.61        """62        msg = self._filter_secrets(msg)63        args = self._filter_secrets(args)64        return super()._log(65            level,66            msg,67            args,68            exc_info=exc_info,69            extra=extra,70            stack_info=stack_info,71            stacklevel=stacklevel,72        )73    def _filter_secrets(self, value: Any) -> Any:74        if isinstance(value, str):75            value = mask(value)76        elif isinstance(value, Exception):77            value_args = list(value.args)78            for index, arg_item in enumerate(value.args):79                if isinstance(value_args[index], str):80                    value_args[index] = mask(arg_item)81            value.args = tuple(value_args)82        elif isinstance(value, tuple):83            value_list = self._filter_secrets(list(value))84            value = tuple(value_list)85        elif isinstance(value, list):86            for index, item in enumerate(value):87                value[index] = self._filter_secrets(item)88        return value89class LogWriter(object):90    def __init__(self, logger: Logger, level: int):91        self._level = level92        self._log = logger93        self._buffer: str = ""94    def write(self, message: str) -> None:95        self._buffer = "".join([self._buffer, message])96        if "\n" in message:97            self.flush()98    def flush(self) -> None:99        if len(self._buffer) > 0:100            self._log.lines(self._level, self._buffer)101            self._buffer = ""...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.