def test_default_file_mode(self, fs):
write_file(fs, "file")
s = fs.stat("file")
assert stat.S_ISREG(s.st_mode)
assert stat.S_IMODE(s.st_mode) == (
stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH
)
def test_exists(self, fs):
fs.mkdir("dir")
write_file(fs, "file")
assert fs.exists("dir")
assert fs.exists("file")
assert not fs.exists("missing")
def test_commits_only_if_dirty(self, fridge, fs):
with pytest.raises(NothingToCommitError):
fridge.commit()
write_file(fs, 'file')
fridge.commit()
with pytest.raises(NothingToCommitError):
fridge.commit()
def test_refparse_with_ambiguous_ref(self, fridge, fridge_core, fs):
write_file(fs, 'mockfile')
fridge.commit()
key = fridge_core.get_head_key()
fridge.branch(key)
with pytest.raises(AmbiguousReferenceError):
fridge.refparse(key)
def test_respects_writable_mode_of_files(self, fs):
fs = MemoryFS()
write_file(fs, "file", u"foo")
fs.chmod("file", stat.S_IRUSR)
assert_file_content_equal(fs, "file", u"foo")
assert_open_raises(fs, "file", errno.EACCES, "a")
assert_open_raises(fs, "file", errno.EACCES, "w")
def test_is_clean(self, fridge, fs):
assert fridge.is_clean()
write_file(fs, 'file')
assert not fridge.is_clean()
fridge.commit()
assert fridge.is_clean()
fs.unlink('file')
assert not fridge.is_clean()
def test_refparse_commit(self, fridge, fridge_core, fs):
write_file(fs, 'mockfile')
fridge.commit()
ref = fridge_core.get_head()
assert ref.type == Reference.BRANCH
assert fridge.refparse(ref.ref) == ref
key = fridge_core.resolve_branch(ref.ref)
assert fridge.refparse(key) == Reference(Reference.COMMIT, key)
def test_commit_and_checkout(self, fridge, fs):
write_file(fs, 'mockfile', u'content')
status = fs.stat('mockfile')
fridge.commit(message='msg')
fs.unlink('mockfile')
fridge.checkout()
assert fs.get_node(['mockfile']).content.decode() == u'content'
assert fs.stat('mockfile') == status
def test_bottomup_walk(self, fs):
write_file(fs, "file")
fs.mkdir("dir")
write_file(fs, "dir/file2")
native_dir_path = os.path.join(os.curdir, "dir")
assert [item for item in fs.walk(".", topdown=False)] == [
(native_dir_path, [], ["file2"]),
(".", ["dir"], ["file"]),
]
def test_rmdir(self, fs):
fs.mkdir("dir")
fs.rmdir("dir")
assert not fs.exists("dir")
fs.mkdir("dirx")
write_file(fs, os.path.join("dirx", "filename"), u"content")
with pytest.raises(OSError) as excinfo:
fs.rmdir("dirx")
assert excinfo.value.errno == errno.ENOTEMPTY
def test_allows_to_store_and_retrieve_files(self, fs):
write_file(fs, 'testfile', u'dummy content')
cas = ContentAddressableStorage('cas', fs=fs)
key = cas.store('testfile')
# Close and reopen
del cas
cas = ContentAddressableStorage('cas', fs=fs)
with fs.open(cas.get_path(key), 'r') as f:
content = f.read()
assert content == u'dummy content'
def test_writing_original_files_keeps_stored_file_unchanged(self, fs):
write_file(fs, 'testfile', u'dummy content')
cas = ContentAddressableStorage('cas', fs=fs)
key = cas.store('testfile')
del cas # Close
write_file(fs, 'testfile', u'replaced content')
cas = ContentAddressableStorage('cas', fs=fs)
assert_file_content_equal(fs, cas.get_path(key), u'dummy content')
def test_symlink_raises_error_if_file_exists(self, fs):
fs.mkdir("sub1")
fs.mkdir("sub2")
src = os.path.join("sub1", "src")
dest = os.path.join("sub2", "dest")
write_file(fs, src, u"dummy")
write_file(fs, dest, u"dummy2")
with pytest.raises(OSError) as excinfo:
fs.symlink(src, dest)
assert excinfo.value.errno == errno.EEXIST
assert excinfo.value.filename == dest
def test_symlink(self, fs):
fs.mkdir("sub1")
fs.mkdir("sub2")
src = os.path.join("sub1", "src")
dest = os.path.join("sub2", "dest")
write_file(fs, src, u"dummy")
fs.symlink(src, dest)
with fs.open(dest, "a+") as f:
f.seek(0, os.SEEK_SET)
assert f.read() == u"dummy"
f.write(u" content")
assert_file_content_equal(fs, src, u"dummy content")
def test_diff(self, fridge, fs):
write_file(fs, 'remove')
write_file(fs, 'update', u'ver1')
write_file(fs, 'unchanged', u'foobar')
fridge.commit()
fs.unlink('remove')
write_file(fs, 'update', u'ver2')
write_file(fs, 'new')
result = fridge.diff()
assert result.removed == ['remove']
assert result.updated == ['update']
assert result.added == ['new']
def test_modifying_walk_dirnames(self, fs):
write_file(fs, "file")
fs.mkdir("dir")
write_file(fs, "dir/file2")
fs.mkdir("excluded")
write_file(fs, "excluded/file3")
for dirpath, dirnames, filenames in fs.walk("."):
if "excluded" in dirnames:
dirnames.remove("excluded")
assert not dirpath.endswith("excluded")
assert "file3" not in filenames
def test_add_blob_and_checkout_blob(self, fs, fridge_core):
write_file(fs, 'path', u'content')
key = fridge_core.add_blob('path')
assert not fs.exists('path')
fridge_core.checkout_blob(key, 'path')
assert fs.get_node(['path']).content.decode() == u'content'
def test_allows_to_store_files_with_identical_content(self, fs, cas):
write_file(fs, 'file1', u'content')
write_file(fs, 'file2', u'content')
key1 = cas.store('file1')
key2 = cas.store('file2')
assert key1 == key2
def test_checkout_blob_on_checkedout(self, fs, fridge_core):
write_file(fs, 'mockfile', u'content')
key = fridge_core.add_blob('mockfile')
fridge_core.checkout_blob(key, 'mockfile')
fridge_core.checkout_blob(key, 'mockfile')
assert fs.get_node(['mockfile']).content.decode() == u'content'
def test_stat_returns_copy(self, fs):
write_file(fs, "file")
s1 = fs.stat("file")
assert s1.st_mode != 0
s1.st_mode = 0
assert fs.stat("file").st_mode != 0
def test_branch_sets_new_head(self, fridge, fridge_core, fs):
write_file(fs, 'mockfile')
fridge.commit()
assert fridge_core.get_head() == Reference(Reference.BRANCH, 'master')
fridge.branch('branch')
assert fridge_core.get_head() == Reference(Reference.BRANCH, 'branch')
def test_utime(self, fs):
write_file(fs, "file")
fs.utime("file", (1.1, 2.2))
st = fs.stat("file")
assert st.st_atime == 1.1
assert st.st_mtime == 2.2
def test_branch_exists(self, fridge, fs):
write_file(fs, 'mockfile')
fridge.commit()
fridge.branch('branch')
with pytest.raises(BranchExistsError):
fridge.branch('branch')
def test_unlink(self, fs):
write_file(fs, "file")
fs.unlink("file")
assert_open_raises(fs, "file", errno.ENOENT)
def test_samefile(self, fs):
write_file(fs, "file1", u"file1")
write_file(fs, "file2", u"file2")
fs.symlink("file1", "file1b")
assert fs.samefile("file1", "file1b")
assert not fs.samefile("file1", "file2")
def test_allows_reading_of_files(self, mode, fs):
write_file(fs, "filename", u"dummy content")
with fs.open("filename", mode) as f:
data = f.read()
assert data == u"dummy content"
def test_allows_overwriting_of_files(self, mode, fs):
write_file(fs, "filename", u"dummy")
with fs.open("filename", mode) as f:
f.write(u"content")
assert fs.children["filename"].content == b"content"
def test_file_size(self, fs):
content = u"filecontent"
write_file(fs, "file", content)
assert fs.stat("file").st_size == len(content)
def test_handles_blobs_with_identical_content(self, fs, fridge_core):
write_file(fs, 'file1', u'content')
write_file(fs, 'file2', u'content')
key1 = fridge_core.add_blob('file1')
key2 = fridge_core.add_blob('file2')
assert key1 == key2
def test_modification_date(self, fs):
write_file(fs, "file")
t1 = fs.stat("file").st_mtime
write_file(fs, "file")
t2 = fs.stat("file").st_mtime
assert t1 < t2
