def test_attrs_fail(init_kwargs_patch, error_type):
"""Verifying that validators are applied because we overwrite attrs init."""
init_kwargs = GOOD_INIT_KWARGS.copy()
init_kwargs.update(init_kwargs_patch)
with pytest.raises(error_type):
metadata.MetadataWriter(**init_kwargs)()
def test_write_metadata_default_output_modes(filename, force_overwrite,
expected_mode):
test = metadata.MetadataWriter(suppress_output=False)(filename)
if force_overwrite:
test.force_overwrite()
assert test._output_mode == expected_mode
def test_metadata_output_file_parent_dir_does_not_exist(tmpdir):
metadata_file = os.path.join(str(tmpdir), "missing_dir", "metadata")
with pytest.raises(BadUserArgumentError) as excinfo:
metadata.MetadataWriter(suppress_output=False)(metadata_file)
excinfo.match(
r"Parent directory for requested metdata file does not exist.")
def test_write_or_suppress_metadata_file(tmpdir, suppress):
my_metadata = {"some": "data", "for": "this metadata"}
output_file = tmpdir.join("metadata")
writer_factory = metadata.MetadataWriter(suppress_output=suppress)
writer = writer_factory(str(output_file))
with writer:
writer.write_metadata(**my_metadata)
if suppress:
assert not output_file.isfile()
else:
assert json.loads(output_file.read()) == my_metadata
def test_write_or_suppress_metadata_stdout(capsys, suppress):
my_metadata = {"some": "data", "for": "this metadata"}
writer_factory = metadata.MetadataWriter(suppress_output=suppress)
writer = writer_factory("-")
with writer:
writer.write_metadata(**my_metadata)
out, _err = capsys.readouterr()
if suppress:
assert out == ""
else:
assert json.loads(out) == my_metadata
def test_write_or_suppress_metadata_file_open_close(tmpdir):
my_metadata = {"some": "data", "for": "this metadata"}
output_file = tmpdir.join("metadata")
writer_factory = metadata.MetadataWriter(suppress_output=False)
writer = writer_factory(str(output_file))
writer.open()
try:
writer.write_metadata(**my_metadata)
finally:
writer.close()
assert json.loads(output_file.read()) == my_metadata
def test_append_metadata_file(tmpdir):
initial_data = "some data"
my_metadata = {"some": "data", "for": "this metadata"}
output_file = tmpdir.join("metadata")
output_file.write_binary((initial_data + os.linesep).encode("utf-8"))
with metadata.MetadataWriter(suppress_output=False)(
str(output_file)) as writer:
writer.write_metadata(**my_metadata)
lines = output_file.readlines()
assert len(lines) == 2
assert lines[0].strip() == initial_data
assert json.loads(lines[1].strip()) == my_metadata
def test_overwrite_metdata_file(tmpdir):
initial_data = "some data"
my_metadata = {"some": "data", "for": "this metadata"}
output_file = tmpdir.join("metadata")
output_file.write(initial_data + os.linesep)
overwrite_writer = metadata.MetadataWriter(suppress_output=False)(
str(output_file))
overwrite_writer.force_overwrite()
with overwrite_writer as writer:
writer.write_metadata(**my_metadata)
lines = output_file.readlines()
assert len(lines) == 1
assert json.loads(lines[0].strip()) == my_metadata
def test_overwrite_metdata_file_multiuse(tmpdir):
initial_data = "some data"
my_metadata = {"some": "data", "for": "this metadata"}
output_file = tmpdir.join("metadata")
output_file.write(initial_data + os.linesep)
long_lived_writer = metadata.MetadataWriter(suppress_output=False)(
str(output_file))
long_lived_writer.force_overwrite()
assert long_lived_writer._output_mode == "wb"
with long_lived_writer as writer:
writer.write_metadata(**my_metadata)
assert long_lived_writer._output_mode == "ab"
with long_lived_writer as writer:
writer.write_metadata(**my_metadata)
lines = output_file.readlines()
assert len(lines) == 2
assert json.loads(lines[0].strip()) == my_metadata
assert lines[0] == lines[1]
def build_expected_good_args(from_file=False): # pylint: disable=too-many-locals
encrypt = "-e"
decrypt = "-d"
suppress_metadata = " -S"
short_input = " -i -"
long_input = " --input -"
short_output = " -o -"
long_output = " --output -"
valid_io = short_input + short_output
mkp_1 = " -w provider=ex_provider_1 key=ex_mk_id_1"
mkp_1_parsed = {"provider": "ex_provider_1", "key": ["ex_mk_id_1"]}
mkp_2 = " -w provider=ex_provider_2 key=ex_mk_id_2"
mkp_2_parsed = {"provider": "ex_provider_2", "key": ["ex_mk_id_2"]}
default_encrypt = encrypt + suppress_metadata + valid_io + mkp_1
good_args = []
# encrypt/decrypt
for encrypt_flag in (encrypt, "--encrypt"):
good_args.append((encrypt_flag + suppress_metadata + valid_io + mkp_1, "action", "encrypt"))
for decrypt_flag in (decrypt, "--decrypt"):
good_args.append((decrypt_flag + suppress_metadata + valid_io + mkp_1, "action", "decrypt"))
# wrapping key config
good_args.append((default_encrypt, "wrapping_keys", [mkp_1_parsed]))
good_args.append((default_encrypt + mkp_2, "wrapping_keys", [mkp_1_parsed, mkp_2_parsed]))
# input/output
for input_flag in (short_input, long_input):
good_args.append((encrypt + suppress_metadata + input_flag + short_output + mkp_1, "input", "-"))
for output_flag in (short_output, long_output):
good_args.append((encrypt + suppress_metadata + output_flag + short_input + mkp_1, "output", "-"))
# encryption context
good_args.append((default_encrypt, "encryption_context", {}))
good_args.append(
(default_encrypt + " -c some=data not=secret", "encryption_context", {"some": "data", "not": "secret"})
)
if from_file:
good_args.append(
(
default_encrypt + ' -c "key with a space=value with a space"',
"encryption_context",
{"key with a space": "value with a space"},
)
)
else:
good_args.append(
(
default_encrypt + ' -c "key with a space=value with a space"',
"encryption_context",
{"key with a space": "value with a space"},
)
)
# algorithm
algorithm_name = "AES_128_GCM_IV12_TAG16"
good_args.append((default_encrypt, "algorithm", None))
good_args.append((default_encrypt + " --algorithm " + algorithm_name, "algorithm", algorithm_name))
# frame length
good_args.append((default_encrypt, "frame_length", None))
good_args.append((default_encrypt + " --frame-length 99", "frame_length", 99))
# max length
good_args.append((default_encrypt, "max_length", None))
good_args.append((default_encrypt + " --max-length 99", "max_length", 99))
# interactive
good_args.append((default_encrypt, "interactive", False))
good_args.append((default_encrypt + " --interactive", "interactive", True))
# no-overwrite
good_args.append((default_encrypt, "no_overwrite", False))
good_args.append((default_encrypt + " --no-overwrite", "no_overwrite", True))
# suffix
good_args.append((default_encrypt + " --suffix .MY_SPECIAL_SUFFIX", "suffix", ".MY_SPECIAL_SUFFIX"))
good_args.append((default_encrypt + " --suffix", "suffix", ""))
# recursive
good_args.append((default_encrypt, "recursive", False))
for recursive_flag in (" -r", " -R", " --recursive"):
good_args.append((default_encrypt + recursive_flag, "recursive", True))
# logging verbosity
good_args.append((default_encrypt, "verbosity", None))
for count in (1, 2, 3, 4):
good_args.append((default_encrypt + " -" + "v" * count, "verbosity", count))
# metadata output
good_args.append((default_encrypt, "metadata_output", metadata.MetadataWriter(suppress_output=True)()))
good_args.append(
(
encrypt + valid_io + mkp_1 + " --metadata-output -",
"metadata_output",
metadata.MetadataWriter(suppress_output=False)(output_file="-"),
)
)
return good_args
@pytest.fixture
def patch_json_ready_header(mocker):
mocker.patch.object(io_handling, "json_ready_header")
return io_handling.json_ready_header
@pytest.fixture
def patch_json_ready_header_auth(mocker):
mocker.patch.object(io_handling, "json_ready_header_auth")
return io_handling.json_ready_header_auth
GOOD_IOHANDLER_KWARGS = dict(
metadata_writer=metadata.MetadataWriter(True)(),
interactive=False,
no_overwrite=False,
decode_input=False,
encode_output=False,
required_encryption_context={},
required_encryption_context_keys=[],
)
@pytest.fixture
def standard_handler():
return io_handling.IOHandler(**GOOD_IOHANDLER_KWARGS)
def test_stdout():
def test_custom_fail(init_kwargs, call_kwargs, error_type, error_message):
with pytest.raises(error_type) as excinfo:
metadata.MetadataWriter(**init_kwargs)(**call_kwargs)
excinfo.match(error_message)
def test_attrs_good(init_kwargs, call_kwargs):
metadata.MetadataWriter(**init_kwargs)(**call_kwargs)
