# -*- coding: utf-8 -*- # Copyright: (c) 2020, Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing import pytest import spnego._text as text class Obj: def __init__(self, str: typing.Optional[str] = None, repr: typing.Optional[str] = None) -> None: self.str = str self.repr = repr def __eq__(self, other: typing.Any) -> bool: return isinstance(other, Obj) and self.str == other.str and self.repr == other.repr def __str__(self) -> str: return self.str # type: ignore[return-value] # Testing this scenario def __repr__(self) -> str: return self.repr # type: ignore[return-value] # Testing this scenario class ObjRepr: def __init__(self, repr: typing.Optional[str] = None) -> None: self.repr = repr def __repr__(self) -> str: return self.repr # type: ignore[return-value] # Testing this scenario class ObjUnicodeError: def __str__(self) -> str: return "café".encode("ascii") # type: ignore[return-value] # Testing this scenario def __repr__(self) -> str: return "café".encode("ascii") # type: ignore[return-value] # Testing this scenario def test_to_bytes_from_bytes(): actual = text.to_bytes(b"\xFF\x00\x7F\x80") assert actual == b"\xFF\x00\x7F\x80" @pytest.mark.parametrize( "value, expected", [ ("cafe", b"cafe"), ("café", b"caf\xc3\xa9"), ("ÜseӜ", b"\x55\xCC\x88\x73\x65\xD3\x9C"), ], ) def test_to_bytes_from_text(value, expected): actual = text.to_bytes(value) assert actual == expected def test_to_bytes_encoding(): actual = text.to_bytes("café", encoding="windows-1252") assert actual == b"caf\xe9" def test_to_bytes_errors(): with pytest.raises(UnicodeEncodeError, match="codec can't encode character"): text.to_bytes("café", encoding="ascii") actual = text.to_bytes("café", encoding="ascii", errors="replace") assert actual == b"caf?" def test_to_bytes_nonstr(): actual = text.to_bytes(Obj(str="café")) assert actual == b"caf\xc3\xa9" def test_to_bytes_nonstr_default(): actual = text.to_bytes(Obj()) assert actual == b"" def test_to_bytes_nonstr_repr(): actual = text.to_bytes(ObjRepr(repr="café")) assert actual == b"caf\xc3\xa9" def test_to_bytes_nonstr_unicode_error(): actual = text.to_bytes(ObjUnicodeError()) assert actual == b"" def test_to_bytes_nonstr_passthru(): actual = text.to_bytes(Obj(), nonstring="passthru") assert actual == Obj() def test_to_bytes_nonstr_empty(): actual = text.to_bytes(Obj(), nonstring="empty") assert actual == b"" def test_to_bytes_nonstr_invalid(): with pytest.raises(ValueError, match="Invalid nonstring value"): text.to_bytes(Obj(), nonstring="invalid") def test_to_text_from_text(): actual = text.to_text("café") assert actual == "café" @pytest.mark.parametrize( "value, expected", [ (b"cafe", "cafe"), (b"caf\xc3\xa9", "café"), (b"\x55\xCC\x88\x73\x65\xD3\x9C", "ÜseӜ"), ], ) def test_to_text_from_bytes(value, expected): actual = text.to_text(value) assert actual == expected def test_to_text_encoding(): actual = text.to_text(b"caf\xe9", encoding="windows-1252") assert actual == "café" def test_to_text_errors(): with pytest.raises(UnicodeError, match="codec can't decode byte 0xff"): text.to_text(b"caf\xFF") actual = text.to_text(b"caf\xFF", errors="replace") assert actual == "caf�" def test_to_text_nonstr(): actual = text.to_text(Obj(str="café")) assert actual == "café" def test_to_text_nonstr_unicode(): class ObjUnicode: def __unicode__(self): return "café" actual = text.to_text(ObjUnicode()) assert actual == "café" def test_to_text_nonstr_default(): actual = text.to_text(Obj()) assert actual == "" def test_to_text_nonstr_repr(): actual = text.to_text(ObjRepr(repr="café")) assert actual == "café" def test_to_text_nonstr_unicode_error(): actual = text.to_text(ObjUnicodeError()) assert actual == "" def test_to_text_nonstr_passthru(): actual = text.to_text(Obj(), nonstring="passthru") assert actual == Obj() def test_to_text_nonstr_empty(): actual = text.to_text(Obj(), nonstring="empty") assert actual == "" def test_to_text_nonstr_invalid(): with pytest.raises(ValueError, match="Invalid nonstring value"): text.to_text(Obj(), nonstring="invalid")