def test_log_repr_dict_values_full(self): from spyne.model import AnyDict from spyne.util.web import log_repr t = AnyDict(logged='values-full') assert log_repr({1: 1, 2: 2, 3: 3}, t) == "{(...): 1, (...): 2, (...): 3}" assert log_repr([1, 2, 3], t) == "[1, 2, 3]"
def test_log_repr_dict_keys_full(self): from spyne.model import AnyDict from spyne.util.web import log_repr t = AnyDict(logged='keys-full') assert log_repr({1: 1, 2: 2, 3: 3}, t) == "{1: (...), 2: (...), 3: (...)}" assert log_repr([1, 2, 3], t) == "[1, 2, 3]"
def test_log_repr_dict_values(self): from spyne.model import AnyDict from spyne.util.web import log_repr t = AnyDict(logged='values') assert log_repr({1: 1}, t) == "{(...): 1}" assert log_repr([1], t) == "[1]"
def test_log_repr_simple(self): from spyne.model.complex import ComplexModel from spyne.model.primitive import String from spyne.util.web import log_repr class Z(ComplexModel): z=String l = MAX_STRING_FIELD_LENGTH + 100 print(log_repr(Z(z="a" * l))) print("Z(z='%s'(...))" % ('a' * MAX_STRING_FIELD_LENGTH)) assert log_repr(Z(z="a" * l)) == "Z(z='%s'(...))" % \ ('a' * MAX_STRING_FIELD_LENGTH) assert log_repr(['a','b','c'], Array(String)) == "['a', 'b', (...)]"
def test_log_repr_simple(self): from spyne.model.complex import ComplexModel from spyne.model.primitive import String from spyne.util.web import log_repr class Z(ComplexModel): z=String l = MAX_STRING_FIELD_LENGTH + 100 print(log_repr(Z(z="a" * l))) print("Z(z='%s'(...))" % ('a' * MAX_STRING_FIELD_LENGTH)) assert log_repr(Z(z="a" * l)) == "Z(z='%s'(...))" % \ ('a' * MAX_STRING_FIELD_LENGTH) assert log_repr(['a','b','c'], Array(String)) == "['a', 'b', 'c']"
def to_cloth(self, ctx, cls, inst, cloth, parent, name=None, from_arr=False, **kwargs): prot_name = self.__class__.__name__ if cloth is None: return self.to_parent(ctx, cls, inst, parent, name, **kwargs) cls, switched = self.get_polymorphic_target(cls, inst) # if there's a subprotocol, switch to it subprot = getattr(cls.Attributes, 'prot', None) if subprot is not None and not (subprot is self): self._enter_cloth(ctx, cloth, parent) return subprot.subserialize(ctx, cls, inst, parent, name, **kwargs) # if instance is None, use the default factory to generate one _df = cls.Attributes.default_factory if inst is None and callable(_df): inst = _df() # if instance is still None, use the default value if inst is None: inst = cls.Attributes.default retval = None if inst is None: identifier = "%s.%s" % (prot_name, "null_to_cloth") logger_s.debug("Writing %s using %s for %s.", name, identifier, cls.get_type_name()) ctx.protocol.tags.add(id(cloth)) if cls.Attributes.min_occurs > 0: parent.write(cloth) else: if not from_arr and cls.Attributes.max_occurs > 1: return self.array_to_cloth(ctx, cls, inst, cloth, parent, name=name) handler = self.rendering_handlers[cls] identifier = "%s.%s" % (prot_name, handler.__name__) logger_s.debug("Writing %s using %s for %s. Inst: %r", name, identifier, cls.get_type_name(), log_repr(inst, cls)) retval = handler(ctx, cls, inst, cloth, parent, name=name) return retval
def validate_native(cls, inst): for k, v in inst.items(): if not isinstance(k, six.string_types): raise ValidationError(type(k), "Invalid key type %r") if not isinstance(v, list): raise ValidationError(type(v), "Invalid value type %r") # log_repr prevents too much data going in the logs. if not len({type(subv) for subv in v}) == 1: raise ValidationError(log_repr(v), "List %s is not uniform") return True
def test_log_repr(self): from spyne.model.complex import ComplexModel from spyne.model.primitive import Integer from spyne.model.primitive import String from spyne.util.web import log_repr class Z(ComplexModel): z=String assert 128 > MAX_STRING_FIELD_LENGTH assert log_repr(Z(z="a"*128)) == "Z(z='%s'(...))" % ('a' * MAX_STRING_FIELD_LENGTH)
def to_cloth(self, ctx, cls, inst, cloth, parent, name=None, from_arr=False, **kwargs): prot_name = self.__class__.__name__ cls_attrs = self.get_cls_attrs(cls) if cloth is None: logger_c.debug("No cloth fround, switching to to_parent...") return self.to_parent(ctx, cls, inst, parent, name, **kwargs) cls, switched = self.get_polymorphic_target(cls, inst) # if there's a subprotocol, switch to it subprot = cls_attrs.prot if subprot is not None and not (subprot is self): self._enter_cloth(ctx, cloth, parent) return subprot.subserialize(ctx, cls, inst, parent, name, **kwargs) # if instance is None, use the default factory to generate one _df = cls_attrs.default_factory if inst is None and callable(_df): inst = _df() # if instance is still None, use the default value if inst is None: inst = cls_attrs.default if inst is None: if cls.Attributes.min_occurs > 0: self._enter_cloth(ctx, cloth, parent) identifier = "%s.%s" % (prot_name, "null_to_cloth") logger_s.debug("Writing '%s' using %s type: %s.", name, identifier, cls.get_type_name()) parent.write(cloth) else: logger_s.debug("Skipping '%s' type: %s because empty.", name, cls.get_type_name()) self._enter_cloth(ctx, cloth, parent, skip=True) return if not from_arr and cls.Attributes.max_occurs > 1: return self.array_to_cloth(ctx, cls, inst, cloth, parent, name=name) handler = self.rendering_handlers[cls] identifier = "%s.%s" % (prot_name, handler.__name__) logger_s.debug("Writing %s using %s for %s. Inst: %r", name, identifier, cls.get_type_name(), log_repr(inst, cls, from_array=from_arr)) retval = handler(ctx, cls, inst, cloth, parent, name=name) return retval
def test_log_repr(self): from spyne.model.complex import ComplexModel from spyne.model.primitive import Integer from spyne.model.primitive import String from spyne.util.web import log_repr class Z(ComplexModel): z = String assert 128 > MAX_STRING_FIELD_LENGTH assert log_repr(Z(z="a" * 128)) == "Z(z='%s'(...))" % ("a" * MAX_STRING_FIELD_LENGTH)
def to_cloth(self, ctx, cls, inst, cloth, parent, name=None, from_arr=False, **kwargs): prot_name = self.__class__.__name__ if cloth is None: return self.to_parent(ctx, cls, inst, parent, name, **kwargs) cls, switched = self.get_polymorphic_target(cls, inst) # if there's a subprotocol, switch to it subprot = getattr(cls.Attributes, 'prot', None) if subprot is not None and not (subprot is self): self._enter_cloth(ctx, cloth, parent) return subprot.subserialize(ctx, cls, inst, parent, name, **kwargs) # if instance is None, use the default factory to generate one _df = cls.Attributes.default_factory if inst is None and callable(_df): inst = _df() # if instance is still None, use the default value if inst is None: inst = cls.Attributes.default retval = None if inst is None: identifier = "%s.%s" % (prot_name, "null_to_cloth") logger_s.debug("Writing %s using %s for %s.", name, identifier, cls.get_type_name()) ctx.protocol.tags.add(id(cloth)) if cls.Attributes.min_occurs > 0: parent.write(cloth) return if not from_arr and cls.Attributes.max_occurs > 1: return self.array_to_cloth(ctx, cls, inst, cloth, parent, name=name) handler = self.rendering_handlers[cls] identifier = "%s.%s" % (prot_name, handler.__name__) logger_s.debug("Writing %s using %s for %s. Inst: %r", name, identifier, cls.get_type_name(), log_repr(inst, cls, from_array=from_arr)) retval = handler(ctx, cls, inst, cloth, parent, name=name) return retval
def test_log_repr_complex(self): from spyne.model import ByteArray from spyne.model import File from spyne.model.complex import ComplexModel from spyne.model.primitive import String from spyne.util.web import log_repr class Z(ComplexModel): _type_info = [ ('f', File(logged=False)), ('t', ByteArray(logged=False)), ('z', Array(String)), ] l = MAX_STRING_FIELD_LENGTH + 100 val = Z(z=["abc"] * l, t=['t'], f=File.Value(name='aaa', data=['t'])) print(repr(val)) assert log_repr(val) == "Z(z=['abc', 'abc', (...)])"
def test_log_repr_dict_vanilla(self): from spyne.model import AnyDict from spyne.util.web import log_repr t = AnyDict assert log_repr({1: 1}, t) == "{1: 1}" assert log_repr({1: 1, 2: 2}, t) == "{1: 1, 2: 2}" assert log_repr({1: 1, 2: 2, 3: 3}, t) == "{1: 1, 2: 2, (...)}" assert log_repr([1], t) == "[1]" assert log_repr([1, 2], t) == "[1, 2]" assert log_repr([1, 2, 3], t) == "[1, 2, (...)]"
def to_parent(self, ctx, cls, inst, parent, name, nosubprot=False, **kwargs): prot_name = self.__class__.__name__ cls, switched = self.get_polymorphic_target(cls, inst) # if there is a subprotocol, switch to it subprot = getattr(cls.Attributes, "prot", None) if subprot is not None and not nosubprot and not (subprot in ctx.protocol.prot_stack): logger.debug("Subprot from %r to %r", self, subprot) return self.to_subprot(ctx, cls, inst, parent, name, subprot, **kwargs) # if there is a class cloth, switch to it ret, cor_handle = self.check_class_cloths(ctx, cls, inst, parent, name, **kwargs) if ret: return cor_handle # if instance is None, use the default factory to generate one _df = cls.Attributes.default_factory if inst is None and callable(_df): inst = _df() # if instance is still None, use the default value if inst is None: inst = cls.Attributes.default # if instance is still None, use the global null handler to serialize it if inst is None and self.use_global_null_handler: identifier = prot_name + ".null_to_parent" logger.debug("Writing %s using %s for %s.", name, identifier, cls.get_type_name()) return self.null_to_parent(ctx, cls, inst, parent, name, **kwargs) # if requested, ignore wrappers if self.ignore_wrappers and issubclass(cls, ComplexModelBase): cls, inst = self.strip_wrappers(cls, inst) # if cls is an iterable of values and it's not been iterated on, do it from_arr = kwargs.get("from_arr", False) if not from_arr and cls.Attributes.max_occurs > 1: return self.array_to_parent(ctx, cls, inst, parent, name, **kwargs) # fetch the serializer for the class at hand try: handler = self.serialization_handlers[cls] except KeyError: # if this protocol uncapable of serializing this class if self.ignore_uncap: logger.debug("Ignore uncap %r", name) return # ignore it if requested # raise the error otherwise logger.error("%r is missing handler for %r for field %r", self, cls, name) raise # push the instance at hand to instance stack. this makes it easier for # protocols to make decisions based on parents of instances at hand. ctx.outprot_ctx.inst_stack.append((cls, inst)) # finally, serialize the value. retval is the coroutine handle if any identifier = "%s.%s" % (prot_name, handler.__name__) logger.debug("Writing %s using %s for %s. Inst: %r", name, identifier, cls.get_type_name(), log_repr(inst, cls)) retval = handler(ctx, cls, inst, parent, name, **kwargs) # FIXME: to_parent must be made to a coroutine for the below to remain # consistent when Iterable.Push is used. ctx.outprot_ctx.inst_stack.pop() return retval
def to_parent(self, ctx, cls, inst, parent, name, nosubprot=False, **kwargs): prot_name = self.__class__.__name__ cls, switched = self.get_polymorphic_target(cls, inst) # if there is a subprotocol, switch to it subprot = getattr(cls.Attributes, 'prot', None) if subprot is not None and not nosubprot and not \ (subprot in ctx.protocol.prot_stack): logger.debug("Subprot from %r to %r", self, subprot) return self.to_subprot(ctx, cls, inst, parent, name, subprot, **kwargs) # if there is a class cloth, switch to it ret, cor_handle = self.check_class_cloths(ctx, cls, inst, parent, name, **kwargs) if ret: return cor_handle # if instance is None, use the default factory to generate one _df = cls.Attributes.default_factory if inst is None and callable(_df): inst = _df() # if instance is still None, use the default value if inst is None: inst = cls.Attributes.default # if instance is still None, use the global null handler to serialize it if inst is None and self.use_global_null_handler: identifier = prot_name + '.null_to_parent' logger.debug("Writing %s using %s for %s.", name, identifier, cls.get_type_name()) return self.null_to_parent(ctx, cls, inst, parent, name, **kwargs) # if requested, ignore wrappers if self.ignore_wrappers and issubclass(cls, ComplexModelBase): cls, inst = self.strip_wrappers(cls, inst) # if cls is an iterable of values and it's not being iterated on, do it from_arr = kwargs.get('from_arr', False) if not from_arr and cls.Attributes.max_occurs > 1: return self.array_to_parent(ctx, cls, inst, parent, name, **kwargs) # fetch the serializer for the class at hand try: handler = self.serialization_handlers[cls] except KeyError: # if this protocol uncapable of serializing this class if self.ignore_uncap: logger.debug("Ignore uncap %r", name) return # ignore it if requested # raise the error otherwise logger.error("%r is missing handler for %r for field %r", self, cls, name) raise # push the instance at hand to instance stack. this makes it easier for # protocols to make decisions based on parents of instances at hand. ctx.outprot_ctx.inst_stack.append((cls, inst, from_arr)) # finally, serialize the value. retval is the coroutine handle if any identifier = "%s.%s" % (prot_name, handler.__name__) log_str = log_repr(inst, cls, from_array=kwargs.get('from_arr', None)) logger.debug("Writing %s using %s for %s. Inst: %r", name, identifier, cls.get_type_name(), log_str) retval = handler(ctx, cls, inst, parent, name, **kwargs) # FIXME: to_parent must be made to a coroutine for the below to remain # consistent when Iterable.Push is used. ctx.outprot_ctx.inst_stack.pop() return retval