def test_encode_multiple_rounds(self):
if PY3:
self.assertRaises(TypeError, codext.encode, b"test", "utf-8[2]")
s = "test"
for i in range(3):
s = codext.encode(s, "morse")
self.assertEqual(s, codext.encode("test", "morse[3]"))
self.assertIsNotNone(codext.encode("test", "base64[10]"))
def test_add_map_codec(self):
ENCMAP = [{
'a': "A",
'b': "B",
'c': "C"
}, {
'd': "D",
'e': "E",
'f': "F"
}, {
'g': "G",
'h': "H",
'i': "I"
}]
self.assertIsNotNone(
codext.add_map("dummy2", ENCMAP,
pattern=r"^dummy2(?:[-_]?(\d))?$"))
self.assertRaises(ValueError, codext.add_map, "dummy2", "BAD_ENCMAP")
self.assertEqual(codext.encode("abc", "dummy2"), "ABC")
self.assertEqual(codext.encode("abc", "dummy2-1"), "ABC")
self.assertEqual(codext.encode("def", "dummy2-2"), "DEF")
self.assertEqual(codext.encode("ghi", "dummy2-3"), "GHI")
self.assertRaises(LookupError, codext.encode, "test", "dummy2-4")
ENCMAP = {'': {'a': "A", 'b': "B"}, r'bad': {'a': "B", 'b': "A"}}
self.assertIsNotNone(
codext.add_map("dummy3",
ENCMAP,
pattern=r"^dummy3([-_]inverted)?$"))
self.assertRaises(LookupError, codext.encode, "test",
"dummy3_inverted")
self.assertRaises(ValueError,
codext.add_map,
"dummy2",
ENCMAP,
ignore_case="BAD")
self.assertRaises(ValueError,
codext.add_map,
"dummy2",
ENCMAP,
intype="BAD")
self.assertRaises(ValueError,
codext.add_map,
"dummy2",
ENCMAP,
outype="BAD")
ci = codext.lookup("dummy2")
for k in [
"category", "encmap", "ignore_case", "intype", "no_error",
"outype", "repl_char", "sep", "text"
]:
self.assertIn(k, ci.parameters.keys())
def parse_request():
"""Get URL from request body and create a database record"""
full_url = request.get_data().decode("utf-8")
new_url = Url(url=full_url)
db.session.add(new_url)
db.session.flush()
# Get index of newly created row
index = new_url.id
db.session.commit()
# Turn index into short code (int->str->zfill->encode)
str_index = str(index).zfill(8)
short_code = codext.encode(str_index, 'base62')
short_url = request.url_root + short_code
return short_url
def test_remove_codec(self):
self.assertIsNone(codext.add("dummy", dummy_encode, dummy_decode))
self.assertEqual(codext.encode("test", "dummy"), "test")
self.assertIsNone(codext.remove("dummy"))
self.assertRaises(LookupError, codext.encode, "test", "dummy")
# special case, when adding a new codec also to the native codecs
# registry, then it won't be possible to remove it further
self.assertIsNone(codecs.add("dummy2", dummy_encode, dummy_decode))
self.assertEqual(codecs.encode("test", "dummy2"), "test")
self.assertIsNone(codecs.remove("dummy2"))
self.assertEqual(codecs.encode("test", "dummy2"), "test")
self.assertIsNone(codecs.register(getregentry))
self.assertEqual(codecs.encode("test", "dummy3"), "test")
self.assertIsNone(codecs.remove("dummy3"))
self.assertEqual(codecs.encode("test", "dummy3"), "test")
def test_add_codec(self):
self.assertRaises(ValueError, codext.add, "test")
self.assertRaises(ValueError, codext.add, "test", "BAD")
self.assertRaises(ValueError, codext.add, "test", lambda: None, "BAD")
self.assertIsNotNone(codext.add("dummy", dummy_encode, dummy_decode))
self.assertEqual(codext.encode("test", "dummy"), "test")
ci = codext.lookup("dummy")
for k in [
"add_to_codecs", "category", "examples", "name", "pattern",
"text"
]:
self.assertIn(k, ci.parameters.keys())
self.assertIsNotNone(
codext.add("dummy_errored", None, dummy_errored_decode,
r"dummy_errored(\d+)$"))
self.assertRaises(AttributeError, codext.lookup, "dummy_errored1")
def test_handle_macros(self):
MACRO = "test-macro-f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2"
STR = "this is a test"
ENC = "H4sIAMrbkmEC/0txzyhIrnQC4QxPj6CcZONAWwAMIDOIFAAAAA=="
codext.remove(MACRO)
l = codext.list_macros()
self.assertTrue(len(l) > 0)
cm = codext.lookup("example-macro")
self.assertIsNotNone(cm)
self.assertRaises(LookupError, codext.lookup, "example-macro", False)
self.assertRaises(ValueError, codext.add_macro, "example-macro",
"base64")
self.assertRaises(ValueError, codext.add_macro, "base64", "base91")
self.assertIsNotNone(repr(cm))
self.assertTrue(hasattr(cm, "parameters"))
self.assertRaises(LookupError, codext.lookup, MACRO)
self.assertIsNone(codext.add_macro(MACRO, "base64", "gzip", "base64"))
self.assertIn(MACRO, codext.list_macros())
self.assertIsNotNone(codext.encode(STR, MACRO))
self.assertEqual(codext.decode(ENC, MACRO), STR)
# insert a bad entry for the list of encodings in the JSON file
PERS_MACROS[MACRO] = "not a list or tuple..."
with open(PERS_MACROS_FILE, 'w') as f:
json.dump(PERS_MACROS, f)
codext.reset()
self.assertRaises(ValueError, codext.lookup, MACRO)
self.assertIsNone(codext.remove(MACRO))
self.assertRaises(LookupError, codext.lookup, MACRO)
self.assertNotIn(MACRO, codext.list_macros())
self.assertIsNone(codext.remove("THIS-MACRO-DOES-NOT-EXIST"))
self.assertIsNone(codext.remove("VALID-MACRO"))
self.assertIsNone(codext.add_macro("VALID-MACRO", "gzip", "base64"))
self.assertIsNone(codext.remove("VALID-MACRO"))
if PY3:
self.assertIsNone(codext.add_macro("VALID-MACRO", "lzma",
"base64"))
self.assertIsNone(codext.remove("VALID-MACRO"))
self.assertRaises(ValueError, codext.add_macro, "SHALL-FAIL", "base26",
"sms", "letter-indices")
def test_rank_input(self):
codext.remove("test_codec")
self.assertRaises(LookupError, codext.encode, "TEST", "test")
codext.add("test_codec",
lambda x, e="strict": (x + "=", len(x)),
lambda x, e="strict": (x[:-1], len(x) - 1),
"^test(?:_codec)?$",
padding_char="=",
no_error=True,
penalty=1.)
STR = "This is a test string !"
ENC = codext.encode(STR, "base64")
self.assertTrue(len(codext.rank(ENC)) > 20)
self.assertEqual(len(codext.rank(ENC, limit=20)), 20)
self.assertIn(
codext.rank(ENC, exclude=["rot"])[0][1],
["base64", "base64-url", "base64-inv"])
self.assertEqual(codext.rank(ENC, include="base")[0][0][1], STR)
self.assertEqual(codext.rank(ENC, include=["base"])[0][0][1], STR)
self.assertIsNotNone(
codext.rank(ENC, include=["base"],
exclude=["does_not_exist"])[0][0][1], STR)
self.assertIsNotNone(
codext.rank("TEST=", include=["test", "base"])[0][0][1], "TEST")
def test_reset_codecs(self):
self.assertIsNone(codext.reset())
self.assertIsNotNone(codext.encode("test", "morse"))
self.assertRaises(LookupError, codext.encode, "test", "dummy")
def test_add_codec(self):
self.assertRaises(ValueError, codext.add, "test")
self.assertRaises(ValueError, codext.add, "test", "BAD")
self.assertRaises(ValueError, codext.add, "test", lambda: None, "BAD")
self.assertIsNone(codext.add("dummy", dummy_encode, dummy_decode))
self.assertEqual(codext.encode("test", "dummy"), "test")
def test_guess_decode(self):
self.assertIsNone(codext.stopfunc._reload_lang())
self.assertIsNotNone(codext.stopfunc._validate("flag"))
_l = lambda d: list(d.items())[0][1] if len(d) > 0 else None
codext.add("test_codec",
lambda x, e="strict": (x + "=", len(x)),
lambda x, e="strict": (x[:-1], len(x) - 1),
"^test(?:_codec)?$",
padding_char="=",
no_error=True,
bonus_func=lambda *a: True,
penalty=-.5)
self.assertIn("test-codec", codext.list_encodings("test"))
self.assertEqual(codext.decode("TEST=", "test"), "TEST")
self.assertEqual(
list(
codext.guess("TEST=",
codext.stopfunc.text,
include="test",
max_depth=2,
scoring_heuristic=False).items())[0][1], "TEST")
self.assertEqual(
list(
codext.guess("TEST=",
codext.stopfunc.text,
include=["test", "base"],
max_depth=2).items())[0][1], "TEST")
STR = "This is a test"
self.assertEqual(
STR, _l(codext.guess("VGhpcyBpcyBhIHRlc3Q=", "a test",
max_depth=1)))
self.assertEqual(
STR,
_l(
codext.guess("CJG3Ix8bVcSRMLOqwDUg28aDsT7",
"a test",
found=["base62"])))
self.assertEqual(
STR,
_l(
codext.guess("VGhpcyBpcyBhIHRlc3Q=",
"a test",
0,
1,
"base",
scoring_heuristic=True,
exclude=["base100"])))
self.assertEqual(
STR,
_l(
codext.guess("VGhpcyBpcyBhIHRlc3Q=", "a test", 0, 1,
["base", "crypto"])))
self.assertEqual(
len(
codext.guess("NOT THE ENCODED TEST STRING",
"a test",
max_depth=1,
exclude=None)), 0)
self.assertIn(
"F1@9",
_l(
codext.guess("VGVzdCBGMUA5ICE=",
codext.stopfunc.flag,
max_depth=1,
stop=False,
show=True)))
self.assertEqual(
len(
codext.guess("VGhpcyBpcyBhIHRlc3Q=",
" a test",
max_depth=1,
include="base",
exclude=("base64", "base64-url"))), 0)
self.assertEqual(
len(
codext.guess("VGhpcyBpcyBhIHRlc3Q=",
" a test",
max_depth=1,
include="base",
scoring_heuristic=True,
exclude=("base64", "base64-url", "atbash"))), 0)
self.assertRaises(ValueError, codext.guess, STR, max_depth=0)
self.assertRaises(ValueError, codext.guess, STR, exclude=42)
for c in ["base", "language", "native", "stegano"]:
e = codext.list(c)
random.shuffle(e)
for ename in e[:10]:
for encoding in codext.lookup(ename).parameters.get(
'guess', [ename])[:10]:
try:
enc = codext.encode(STR, encoding)
except (NotImplementedError, ValueError):
continue
except TypeError:
enc = codext.encode(b(STR), encoding)
if codext.decode(enc, encoding) == STR:
continue
for found_encodings, found_dec in codext.guess(
enc,
"a test",
0,
1, [c],
scoring_heuristic=True,
debug=True).items():
self.assertEqual(
ensure_str(STR).lower(),
ensure_str(found_dec).lower())
if c != "base":
# do not check for base as the guessed encoding name can be different, e.g.:
# actual: base2
# guessed: base2-generic
if "-icase" in encoding:
self.assertEqual(encoding.lower(),
found_encodings[0].lower())
else:
self.assertEqual(encoding, found_encodings[0])
txt = "".join(chr(i) for i in range(256))
b64 = codext.encode(txt, "base64")
self.assertEqual(
txt,
_l(
codext.guess(b64,
"0123456789",
max_depth=1,
scoring_heuristic=True,
include="base")))
self.assertRaises(ValueError, codext.stopfunc._reload_lang,
"DOES_NOT_EXIST")
def test_reset_codecs(self):
self.assertIsNone(codext.reset())
self.assertIsNotNone(codext.encode("test", "morse"))
self.assertRaises(LookupError, codext.encode, "test", "dummy")
self.assertTrue(len(CODECS_OVERWRITTEN) > 0)
self.assertIsNotNone(str(CODECS_OVERWRITTEN[0]))
