def test_abspath_write(local_test_path):
u = AbsPath(local_test_path + "/test_abspath_write.tmp")
assert not u.exists
u.write("test")
assert u.exists and u.read() == "test"
u.rm()
# this will be tested more with multiple threads in test_race_cond.py
assert not u.exists
u.write("test2", no_lock=True)
assert u.exists and u.read() == "test2"
u.rm()
assert not u.exists
def test_abspath_soft_link(local_test_path, local_v6_txt):
u_src = AbsPath(local_v6_txt)
f = os.path.join(local_test_path, "test_abspath_soft_link", "v6.txt")
u_target = AbsPath(f)
u_target.mkdir_dirname()
u_src.soft_link(u_target)
assert u_target.exists and u_target.read() == v6_txt_contents()
assert u_src.uri == os.path.realpath(u_target.uri)
with pytest.raises(OSError):
# file already exists
u_src.soft_link(u_target)
# no error if force
u_src.soft_link(u_target, force=True)
u_target.rm()
def test_abspath_get_metadata(local_v6_txt, v6_txt_size, v6_txt_md5_hash):
u = AbsPath(local_v6_txt)
m1 = u.get_metadata()
assert m1.md5 == v6_txt_md5_hash
assert m1.size == v6_txt_size
m2 = u.get_metadata(skip_md5=True)
assert m2.md5 is None
assert m2.size == v6_txt_size
u_md5 = AbsPath(local_v6_txt + ".md5")
if u_md5.exists:
u_md5.rm()
m3 = u.get_metadata(make_md5_file=True)
assert m3.md5 == v6_txt_md5_hash
assert m3.size == v6_txt_size
assert u_md5.exists
assert u_md5.read() == v6_txt_md5_hash
def test_abspath_read(local_v6_txt):
u = AbsPath(local_v6_txt)
assert u.read() == v6_txt_contents()
assert u.read(byte=True) == v6_txt_contents().encode()
def test_abspath_cp(local_v6_txt, local_test_path, s3_test_path, gcs_test_path,
url_test_path) -> "AutoURI":
"""Test copying local_v6_txt to the following destination storages:
local_test_path: local -> local
s3_test_path: local -> s3
gcs_test_path: local -> gcs
Parameters to be tested:
no_lock:
Copy with no locking mechanism. There is no way to test this thoroughly here.
This will be tested with multiple threads later in test_rece_cond.py.
no_checksum:
Don't check md5-hash/size/mtime to skip copying (even if file already exists on destination).
make_md5_file:
Make md5 file on destination only when it's REQUIRED.
It's required only if we need to compare md5 hash of source and target.
"""
u = AbsPath(local_v6_txt)
basename = os.path.basename(local_v6_txt)
for test_path in (local_test_path, s3_test_path, gcs_test_path):
u_dest = AutoURI(os.path.join(test_path, "test_abspath_cp", basename))
if u_dest.exists:
u_dest.rm()
assert not u_dest.exists
_, ret = u.cp(u_dest, return_flag=True)
assert u_dest.exists and u.read() == u_dest.read() and ret == 0
u_dest.rm()
assert not u_dest.exists
# cp without lock will be tested throughly in test_race_cond.py
_, ret = u.cp(u_dest, no_lock=True, return_flag=True)
assert u_dest.exists and u.read() == u_dest.read() and ret == 0
u_dest.rm()
# trivial: copy without checksum when target doesn't exists
assert not u_dest.exists
_, ret = u.cp(u_dest, no_checksum=True, return_flag=True)
assert u_dest.exists and u.read() == u_dest.read() and ret == 0
# copy without checksum when target exists
m_dest = u_dest.get_metadata()
assert m_dest.exists
time.sleep(1)
_, ret = u.cp(u_dest, no_checksum=True, return_flag=True)
# compare new mtime vs old mtime
# new time should be larger if it's overwritten as intended
assert u_dest.mtime > m_dest.mtime and u.read() == u_dest.read(
) and ret == 0
# copy with checksum when target exists
m_dest = u_dest.get_metadata()
assert m_dest.exists
_, ret = u.cp(u_dest, return_flag=True)
# compare new mtime vs old mtime
# new time should be the same as old time
assert u_dest.mtime == m_dest.mtime and u.read() == u_dest.read(
) and ret == 1
# make_md5_file works only when it's required
# i.e. when we need to compare md5 hash of src vs target
# so target must exist prior to test it
assert u_dest.exists
# delete md5 file if exists
u_dest_md5_file = AutoURI(u_dest.uri + URIBase.MD5_FILE_EXT)
if u_dest_md5_file.exists:
u_dest_md5_file.rm()
_, ret = u.cp(u_dest, make_md5_file=True, return_flag=True)
assert u_dest.exists and u.read() == u_dest.read() and ret == 1
u_dest.rm()
