# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Unit tests for file timestamp updates."""
import time
import unittest
from collections import namedtuple
from pyfakefs.tests.test_utils import RealFsTestCase
FileTime = namedtuple("FileTime", "st_ctime, st_atime, st_mtime")
class FakeStatTestBase(RealFsTestCase):
def setUp(self):
super().setUp()
# we disable the tests for MacOS to avoid very long builds due
# to the 1s time resolution - we know that the functionality is
# similar to Linux
self.check_linux_and_windows()
self.file_path = self.make_path("some_file")
# MacOS has a timestamp resolution of 1 second
self.sleep_time = 1.1 if self.is_macos else 0.01
self.mode = ""
def stat_time(self, path):
stat = self.os.stat(path)
if self.use_real_fs():
# sleep a bit so in the next call the time has changed
time.sleep(self.sleep_time)
else:
# calling time.time() advances mocked time
time.time()
return FileTime(
st_ctime=stat.st_ctime,
st_atime=stat.st_atime,
st_mtime=stat.st_mtime,
)
def assertLessExceptWindows(self, time1, time2):
if self.is_windows_fs:
self.assertLessEqual(time1, time2)
else:
self.assertLess(time1, time2)
def assertLessExceptPosix(self, time1, time2):
if self.is_windows_fs:
self.assertLess(time1, time2)
else:
self.assertEqual(time1, time2)
def open_close_new_file(self):
with self.mock_time():
with self.open(self.file_path, self.mode, encoding="utf8"):
created = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return created, closed
def open_write_close_new_file(self):
with self.mock_time():
with self.open(self.file_path, self.mode, encoding="utf8") as f:
created = self.stat_time(self.file_path)
f.write("foo")
written = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return created, written, closed
def open_close(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, self.mode, encoding="utf8"):
opened = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, closed
def open_write_close(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, self.mode, encoding="utf8") as f:
opened = self.stat_time(self.file_path)
f.write("foo")
written = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, written, closed
def open_flush_close(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, self.mode, encoding="utf8") as f:
opened = self.stat_time(self.file_path)
f.flush()
flushed = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, flushed, closed
def open_write_flush(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, self.mode, encoding="utf8") as f:
opened = self.stat_time(self.file_path)
f.write("foo")
written = self.stat_time(self.file_path)
f.flush()
flushed = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, written, flushed, closed
def open_read_flush(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, "r", encoding="utf8") as f:
opened = self.stat_time(self.file_path)
f.read()
read = self.stat_time(self.file_path)
f.flush()
flushed = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, read, flushed, closed
def open_read_close_new_file(self):
with self.mock_time():
with self.open(self.file_path, self.mode, encoding="utf8") as f:
created = self.stat_time(self.file_path)
f.read()
read = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return created, read, closed
def open_read_close(self):
with self.mock_time():
self.create_file(self.file_path)
before = self.stat_time(self.file_path)
with self.open(self.file_path, self.mode, encoding="utf8") as f:
opened = self.stat_time(self.file_path)
f.read()
read = self.stat_time(self.file_path)
closed = self.stat_time(self.file_path)
return before, opened, read, closed
def check_open_close_new_file(self):
"""
When a file is created on opening and closed again,
no timestamps are updated on close.
"""
created, closed = self.open_close_new_file()
self.assertEqual(created.st_ctime, closed.st_ctime)
self.assertEqual(created.st_atime, closed.st_atime)
self.assertEqual(created.st_mtime, closed.st_mtime)
def check_open_write_close_new_file(self):
"""
When a file is created on opening, st_ctime is updated under Posix,
and st_mtime is updated on close.
"""
created, written, closed = self.open_write_close_new_file()
self.assertEqual(created.st_ctime, written.st_ctime)
self.assertLessExceptWindows(written.st_ctime, closed.st_ctime)
self.assertEqual(created.st_atime, written.st_atime)
self.assertLessEqual(written.st_atime, closed.st_atime)
self.assertEqual(created.st_mtime, written.st_mtime)
self.assertLess(written.st_mtime, closed.st_mtime)
def check_open_close_w_mode(self):
"""
When an existing file is opened with 'w' or 'w+' mode, st_ctime (Posix
only) and st_mtime are updated on open (truncating), but not on close.
"""
before, opened, closed = self.open_close()
self.assertLessExceptWindows(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, closed.st_ctime)
self.assertLessEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, closed.st_atime)
self.assertLess(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, closed.st_mtime)
def check_open_close_non_w_mode(self):
"""
When an existing file is opened with any mode other than 'w' or 'w+',
no timestamps are updated.
"""
before, opened, closed = self.open_close()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, closed.st_mtime)
def check_open_write_close_w_mode(self):
"""
When an existing file is opened with 'w' or 'w+' mode and is then
written to, st_ctime (Posix only) and st_mtime are updated on open
(truncating) and again on close (flush), but not when written to.
"""
before, opened, written, closed = self.open_write_close()
self.assertLessExceptWindows(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, written.st_ctime)
self.assertLessExceptWindows(written.st_ctime, closed.st_ctime)
self.assertLessEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, written.st_atime)
self.assertLessEqual(written.st_atime, closed.st_atime)
self.assertLess(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, written.st_mtime)
self.assertLess(written.st_mtime, closed.st_mtime)
def check_open_flush_close_w_mode(self):
"""
When an existing file is opened with 'w' or 'w+' mode (truncating),
st_ctime (Posix only) and st_mtime are updated. No updates are done
on flush or close.
"""
before, opened, flushed, closed = self.open_flush_close()
self.assertLessExceptWindows(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, flushed.st_ctime)
self.assertEqual(flushed.st_ctime, closed.st_ctime)
self.assertLessEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, flushed.st_atime)
self.assertEqual(flushed.st_atime, closed.st_atime)
self.assertLess(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, flushed.st_mtime)
self.assertEqual(flushed.st_mtime, closed.st_mtime)
def check_open_flush_close_non_w_mode(self):
"""
When an existing file is opened with any mode other than 'w' or 'w+',
flushed and closed, no timestamps are updated.
"""
before, opened, flushed, closed = self.open_flush_close()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, flushed.st_ctime)
self.assertEqual(flushed.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, flushed.st_atime)
self.assertEqual(flushed.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, flushed.st_mtime)
self.assertEqual(flushed.st_mtime, closed.st_mtime)
def check_open_read_close_non_w_mode(self):
"""
Reading from a file opened with 'r', 'r+', or 'a+' mode updates
st_atime under Posix.
"""
before, opened, read, closed = self.open_read_close()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, read.st_ctime)
self.assertEqual(read.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertLessEqual(opened.st_atime, read.st_atime)
self.assertEqual(read.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, read.st_mtime)
self.assertEqual(read.st_mtime, closed.st_mtime)
def check_open_read_close_new_file(self):
"""
When a file is created with 'w+' or 'a+' mode and then read from,
st_atime is updated under Posix.
"""
created, read, closed = self.open_read_close_new_file()
self.assertEqual(created.st_ctime, read.st_ctime)
self.assertEqual(read.st_ctime, closed.st_ctime)
self.assertLessEqual(created.st_atime, read.st_atime)
self.assertEqual(read.st_atime, closed.st_atime)
self.assertEqual(created.st_mtime, read.st_mtime)
self.assertEqual(read.st_mtime, closed.st_mtime)
def check_open_write_close_non_w_mode(self):
"""
When an existing file is opened with 'a', 'a+' or 'r+' mode
and is then written to, st_ctime (Posix only) and st_mtime are
updated close (flush), but not on opening or when written to.
"""
before, opened, written, closed = self.open_write_close()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, written.st_ctime)
self.assertLessExceptWindows(written.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, written.st_atime)
self.assertLessEqual(written.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, written.st_mtime)
self.assertLess(written.st_mtime, closed.st_mtime)
def check_open_write_flush_close_w_mode(self):
"""
When an existing file is opened with 'w' or 'w+' mode
and is then written to, st_ctime (Posix only) and st_mtime are
updated on open (truncating). Under Posix, st_mtime is updated on
flush, under Windows, on close instead.
"""
before, opened, written, flushed, closed = self.open_write_flush()
self.assertLessEqual(before.st_ctime, opened.st_ctime)
self.assertLessEqual(written.st_ctime, flushed.st_ctime)
self.assertEqual(opened.st_ctime, written.st_ctime)
self.assertEqual(flushed.st_ctime, closed.st_ctime)
self.assertLessEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, written.st_atime)
self.assertLessEqual(written.st_atime, flushed.st_atime)
self.assertLessEqual(flushed.st_atime, closed.st_atime)
self.assertLess(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, written.st_mtime)
self.assertLessExceptWindows(written.st_mtime, flushed.st_mtime)
self.assertLessEqual(flushed.st_mtime, closed.st_mtime)
def check_open_write_flush_close_non_w_mode(self):
"""
When an existing file is opened with 'a', 'a+' or 'r+' mode
and is then written to, st_ctime and st_mtime are updated on flush
under Posix. Under Windows, only st_mtime is updated on close instead.
"""
before, opened, written, flushed, closed = self.open_write_flush()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, written.st_ctime)
self.assertLessExceptWindows(written.st_ctime, flushed.st_ctime)
self.assertEqual(flushed.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertEqual(opened.st_atime, written.st_atime)
self.assertLessEqual(written.st_atime, flushed.st_atime)
self.assertLessEqual(flushed.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, written.st_mtime)
self.assertLessExceptWindows(written.st_mtime, flushed.st_mtime)
self.assertLessEqual(flushed.st_mtime, closed.st_mtime)
class TestFakeModeW(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "w"
def test_open_close_new_file(self):
self.check_open_close_new_file()
def test_open_write_close_new_file(self):
self.check_open_write_close_new_file()
def test_open_close(self):
self.check_open_close_w_mode()
def test_open_write_close(self):
self.check_open_write_close_w_mode()
def test_open_flush_close(self):
self.check_open_flush_close_w_mode()
def test_open_write_flush_close(self):
self.check_open_write_flush_close_w_mode()
def test_read_raises(self):
with self.open(self.file_path, "w", encoding="utf8") as f:
with self.assertRaises(OSError):
f.read()
class TestRealModeW(TestFakeModeW):
def use_real_fs(self):
return True
class TestFakeModeWPlus(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "w+"
def test_open_close_new_file(self):
self.check_open_close_new_file()
def test_open_write_close_new_file(self):
self.check_open_write_close_new_file()
def test_open_read_close_new_file(self):
self.check_open_read_close_new_file()
def test_open_close(self):
self.check_open_close_w_mode()
def test_open_write_close(self):
self.check_open_write_close_w_mode()
def test_open_read_close(self):
"""
When an existing file is opened with 'w+' mode and is then written to,
st_ctime (Posix only) and st_mtime are updated on open
(truncating) and again on close (flush). Under Posix, st_atime is
updated on read.
"""
before, opened, read, closed = self.open_read_close()
self.assertLessExceptWindows(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, read.st_ctime)
self.assertEqual(read.st_ctime, closed.st_ctime)
self.assertLessEqual(before.st_atime, opened.st_atime)
self.assertLessEqual(opened.st_atime, read.st_atime)
self.assertEqual(read.st_atime, closed.st_atime)
self.assertLess(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, read.st_mtime)
self.assertEqual(read.st_mtime, closed.st_mtime)
def test_open_flush_close(self):
self.check_open_flush_close_w_mode()
def test_open_write_flush_close(self):
self.check_open_write_flush_close_w_mode()
class TestRealModeWPlus(TestFakeModeWPlus):
def use_real_fs(self):
return True
class TestFakeModeA(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "a"
def test_open_close_new_file(self):
self.check_open_close_new_file()
def test_open_write_close_new_file(self):
self.check_open_write_close_new_file()
def test_open_close(self):
self.check_open_close_non_w_mode()
def test_open_write_close(self):
self.check_open_write_close_non_w_mode()
def test_open_flush_close(self):
self.check_open_flush_close_non_w_mode()
def test_open_write_flush_close(self):
self.check_open_write_flush_close_non_w_mode()
def test_read_raises(self):
with self.open(self.file_path, "a", encoding="utf8") as f:
with self.assertRaises(OSError):
f.read()
class TestRealModeA(TestFakeModeA):
def use_real_fs(self):
return True
class TestFakeModeAPlus(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "a+"
def test_open_close_new_file(self):
self.check_open_close_new_file()
def test_open_write_close_new_file(self):
self.check_open_write_close_new_file()
def test_open_read_close_new_file(self):
self.check_open_read_close_new_file()
def test_open_close(self):
self.check_open_close_non_w_mode()
def test_open_write_close(self):
self.check_open_write_close_non_w_mode()
def test_open_read_close(self):
self.check_open_read_close_non_w_mode()
def test_open_flush_close(self):
self.check_open_flush_close_non_w_mode()
def test_open_write_flush_close(self):
self.check_open_write_flush_close_non_w_mode()
class TestRealModeAPlus(TestFakeModeAPlus):
def use_real_fs(self):
return True
class TestFakeModeR(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "r"
def test_open_close(self):
self.check_open_close_non_w_mode()
def test_open_read_close(self):
self.check_open_read_close_non_w_mode()
def test_open_flush_close(self):
self.check_open_flush_close_non_w_mode()
def test_open_read_flush_close(self):
"""
When an existing file is opened with 'r' mode, read, flushed and
closed, st_atime is updated after reading under Posix.
"""
before, opened, read, flushed, closed = self.open_read_flush()
self.assertEqual(before.st_ctime, opened.st_ctime)
self.assertEqual(opened.st_ctime, read.st_ctime)
self.assertEqual(read.st_ctime, flushed.st_ctime)
self.assertEqual(flushed.st_ctime, closed.st_ctime)
self.assertEqual(before.st_atime, opened.st_atime)
self.assertLessEqual(opened.st_atime, read.st_atime)
self.assertEqual(read.st_atime, flushed.st_atime)
self.assertEqual(flushed.st_atime, closed.st_atime)
self.assertEqual(before.st_mtime, opened.st_mtime)
self.assertEqual(opened.st_mtime, read.st_mtime)
self.assertEqual(read.st_mtime, flushed.st_mtime)
self.assertEqual(flushed.st_mtime, closed.st_mtime)
def test_open_not_existing_raises(self):
with self.assertRaises(OSError):
with self.open(self.file_path, "r"):
pass
class TestRealModeR(TestFakeModeR):
def use_real_fs(self):
return True
class TestFakeModeRPlus(FakeStatTestBase):
def setUp(self):
super().setUp()
self.mode = "r+"
def test_open_close(self):
self.check_open_close_non_w_mode()
def test_open_write_close(self):
self.check_open_write_close_non_w_mode()
def test_open_read_close(self):
self.check_open_read_close_non_w_mode()
def test_open_flush_close(self):
self.check_open_flush_close_non_w_mode()
def test_open_write_flush_close(self):
self.check_open_write_flush_close_non_w_mode()
def test_open_not_existing_raises(self):
with self.assertRaises(OSError):
with self.open(self.file_path, "r+"):
pass
class TestRealModeRPlus(TestFakeModeRPlus):
def use_real_fs(self):
return True
if __name__ == "__main__":
unittest.main()
|