| # 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): |
| 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) 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): |
| 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) 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) 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) 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') 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) 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) 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(TestFakeModeW, self).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') 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(TestFakeModeWPlus, self).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(TestFakeModeA, self).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') 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(TestFakeModeAPlus, self).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(TestFakeModeR, self).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(TestFakeModeRPlus, self).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() |
