def test_case_clarify_write_inverts_read_example(self):
"""Tests the write then read workflow of keyring.clarify."""
theResult = False
someMessageText = str("This is a test Message")
try:
from piaplib.keyring import clarify as clarify
if clarify.__name__ is None:
raise ImportError("Failed to import clarify")
elif (clarify.hasBackendCommand() is not True):
raise unittest.SkipTest("Requires backend tool")
from piaplib.keyring import rand as rand
if rand.__name__ is None:
raise ImportError("Failed to import rand")
sometestfile = str("/tmp/the_test_file.enc")
theteststore = clarify.makeKeystoreFile(
str("testkeyneedstobelong"),
str("/tmp/.weak_test_key_{}").format(rand.randInt(1, 10, 99)))
self.assertIsNotNone(theteststore,
"Bad Test Env: No Test Keystore")
test_write = clarify.packToFile(sometestfile, str(someMessageText),
theteststore)
self.assertTrue(test_write)
if (test_write is True):
test_read = clarify.unpackFromFile(sometestfile, theteststore)
clean_temp_file(theteststore)
try:
if isinstance(test_read, bytes):
test_read = test_read.decode(
"""utf-8""", errors=clarify.getCTLModeForPY())
except UnicodeDecodeError:
test_read = str(repr(bytes(test_read, """utf-8""")))
self.assertIsNotNone(test_read)
self.assertIsInstance(test_read, str,
"Test output is Not a string")
self.assertIsInstance(someMessageText, str,
"Test input is Not a string")
if (str(someMessageText) in str(test_read)):
theResult = True
else:
if sys.platform.startswith(
"linux") or sys.platform.startswith("darwin"):
print(str(repr(bytes(test_read, """utf-8"""))))
theResult = False
else:
raise unittest.SkipTest(
"BETA. Experemental feature not ready yet.")
except Exception as err:
print(str(""))
print(str(type(err)))
print(str(err))
print(str((err.args)))
print(str(""))
err = None
del err
if sys.platform.startswith("linux"):
theResult = False
else:
raise unittest.SkipTest(
"BETA. Experemental feature not ready yet.")
self.assertTrue(theResult, """the write then read workflow failed""")
def test_z_case_clarify_setKeyFile_none(self):
"""Tests the helper function makeKeystoreFile(None) of keyring.clarify"""
theResult = False
try:
from piaplib.keyring import clarify as clarify
if clarify.__name__ is None:
raise ImportError("Failed to import clarify")
self.assertIsNotNone(clarify.makeKeystoreFile(None))
theResult = True
except Exception as err:
print(str(""))
print(str(type(err)))
print(str(err))
print(str((err.args)))
print(str(""))
self.skip(str("""[CWE-754] Error prevents proper test."""))
err = None
del err
theResult = False
assert theResult
def test_case_clarify_write_inverts_read(self, someInput): # noqa C901
"""Tests the write then read workflow of keyring.clarify with fuzzing."""
theResult = False
someInput = str(someInput)
assume(isinstance(someInput, str))
assume(len(str(someInput)) > 3)
assume("""\"""" not in str(someInput))
assume("""'""" not in str(someInput))
assume(repr(str(someInput)) not in repr(str(repr(someInput))))
from piaplib.pku import utils as utils
if utils.__name__ is None:
raise ImportError("Failed to import utils")
assume(str(someInput) in utils.literal_str(someInput))
assume(utils.literal_str(someInput) in str(someInput))
assume(
utils.literal_str(someInput) in utils.literal_code(str(someInput)))
assume(
utils.literal_code(str(someInput)) in utils.literal_str(someInput))
assume(someInput in str(someInput))
someMessageText = str(repr(someInput))
try:
from piaplib.keyring import clarify as clarify
if clarify.__name__ is None:
raise ImportError("Failed to import clarify")
elif (clarify.hasBackendCommand() is not True):
raise unittest.SkipTest("Requires backend tool")
from piaplib.keyring import rand as rand
if rand.__name__ is None:
raise ImportError("Failed to import rand")
sometestfile = str("./the_test_file.enc")
theteststore = clarify.makeKeystoreFile(
str("testkeyneedstobelong"),
str("./.weak_test_key_{}").format(rand.randInt(1, 10, 99)))
assume((theteststore is not None))
self.assertIsNotNone(theteststore)
test_write = clarify.packToFile(sometestfile, str(someMessageText),
theteststore)
assume(test_write is True)
self.assertTrue(test_write)
check_wrap = clarify.packForRest(str(someMessageText),
theteststore)
assume((check_wrap is not None))
try:
note(
str("encoded: \"{}\"").format(
utils.literal_str(someMessageText)))
note(str("as str: \"{}\"").format(str(someMessageText)))
note(
str("as data: \"{}\"").format(
utils.literal_str(check_wrap)))
except Exception as noteErr:
raise unittest.SkipTest(noteErr)
noteErr = None
del noteErr
if (test_write is True):
test_read = clarify.unpackFromFile(sometestfile, theteststore)
try:
if isinstance(test_read, bytes):
test_read = test_read.decode(
"""utf-8""", errors=clarify.getCTLModeForPY())
except UnicodeDecodeError:
test_read = str(repr(bytes(test_read, """utf-8""")))
assume(False)
self.assertIsNotNone(test_read)
if (str(someMessageText) in str(test_read)):
theResult = True
else:
note(
str("failed test: \"{}\" is not in \"{}\"").format(
str(someMessageText), str(test_read)))
note(
str("decoded: \"{}\"").format(
utils.literal_str(test_read)))
note(
str("should decoded: \"{}\"").format(
utils.literal_code(str(someMessageText))))
note(
str("from undecoded: \"{}\"").format(
utils.literal_str(utils.readFile(sometestfile))))
note(
str("with keystore: \"{}\"").format(
utils.literal_str(theteststore)))
theResult = False
clean_temp_file(theteststore)
except Exception as err:
print(str(""))
print(str(type(err)))
print(str(err))
print(str((err.args)))
print(str(""))
err = None
del err
if sys.platform.startswith("linux"):
theResult = False
else:
raise unittest.SkipTest(
"BETA. Experemental feature not ready yet.")
self.assertTrue(theResult,
"""fuzzing the write then read workflow failed""")