| # Copyright 2014 Altera Corporation. All Rights Reserved. |
| # Author: John McGehee |
| # |
| # 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. |
| |
| """ |
| Test the :py:class`pyfakefs.example` module to demonstrate the usage of the |
| :py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class. |
| |
| Fake filesystem functions like `create_file()`, `create_dir()` or |
| `create_symlink()` are often used to set up file structures at the beginning |
| of a test. |
| While you could also use the familiar `open()`, `os.mkdirs()` and similar |
| functions, these functions can make the test code shorter and more readable. |
| `create_file()` is particularly convenient because it creates all parent |
| directories and allows you to specify the contents or the size of the file. |
| """ |
| |
| import io |
| import os |
| import sys |
| import unittest |
| |
| from pyfakefs import fake_filesystem_unittest |
| from pyfakefs.extra_packages import use_scandir_package |
| from pyfakefs.tests import example # The module under test |
| |
| |
| def load_tests(loader, tests, ignore): |
| """Load the pyfakefs/example.py doctest tests into unittest.""" |
| return fake_filesystem_unittest.load_doctests( |
| loader, tests, ignore, example) |
| |
| |
| class TestExample(fake_filesystem_unittest.TestCase): # pylint: disable=R0904 |
| """Test the example module. |
| The os and shutil modules have been replaced with the fake modules, |
| so that all of the calls to os and shutil in the tested example code |
| occur in the fake filesystem. |
| """ |
| |
| def setUp(self): |
| """Invoke the :py:class:`pyfakefs.fake_filesystem_unittest.TestCase` |
| `self.setUp()` method. This defines: |
| |
| * Attribute `self.fs`, an instance of |
| :py:class:`pyfakefs.fake_filesystem.FakeFilesystem`. This is useful |
| for creating test files. |
| * Attribute `self.stubs`, an instance of |
| :py:class:`pyfakefs.mox3_stubout.StubOutForTesting`. Use this if |
| you need to define additional stubs. |
| """ |
| |
| # This is before setUpPyfakefs(), so still using the real file system |
| self.filepath = os.path.realpath(__file__) |
| with io.open(self.filepath, 'rb') as f: |
| self.real_contents = f.read() |
| |
| self.setUpPyfakefs() |
| |
| def tearDown(self): |
| # No longer need self.tearDownPyfakefs() |
| pass |
| |
| def test_create_file(self): |
| """Test example.create_file() which uses `open()` and `file.write()`. |
| """ |
| self.assertFalse(os.path.isdir('/test')) |
| os.mkdir('/test') |
| self.assertTrue(os.path.isdir('/test')) |
| |
| self.assertFalse(os.path.exists('/test/file.txt')) |
| example.create_file('/test/file.txt') |
| self.assertTrue(os.path.exists('/test/file.txt')) |
| |
| def test_delete_file(self): |
| """Test example.delete_file() which uses `os.remove()`.""" |
| self.fs.create_file('/test/full.txt', |
| contents='First line\n' |
| 'Second Line\n') |
| self.assertTrue(os.path.exists('/test/full.txt')) |
| example.delete_file('/test/full.txt') |
| self.assertFalse(os.path.exists('/test/full.txt')) |
| |
| def test_file_exists(self): |
| """Test example.path_exists() which uses `os.path.exists()`.""" |
| self.assertFalse(example.path_exists('/test/empty.txt')) |
| self.fs.create_file('/test/empty.txt') |
| self.assertTrue(example.path_exists('/test/empty.txt')) |
| |
| def test_get_globs(self): |
| """Test example.get_glob().""" |
| self.assertFalse(os.path.isdir('/test')) |
| self.fs.create_dir('/test/dir1/dir2a') |
| self.assertTrue(os.path.isdir('/test/dir1/dir2a')) |
| # os.mkdirs() works, too. |
| os.makedirs('/test/dir1/dir2b') |
| self.assertTrue(os.path.isdir('/test/dir1/dir2b')) |
| |
| self.assertEqual(example.get_glob('/test/dir1/nonexistent*'), |
| []) |
| is_windows = sys.platform.startswith('win') |
| matching_paths = sorted(example.get_glob('/test/dir1/dir*')) |
| if is_windows: |
| self.assertEqual(matching_paths, |
| [r'\test\dir1\dir2a', r'\test\dir1\dir2b']) |
| else: |
| self.assertEqual(matching_paths, |
| ['/test/dir1/dir2a', '/test/dir1/dir2b']) |
| |
| def test_rm_tree(self): |
| """Test example.rm_tree() using `shutil.rmtree()`.""" |
| self.fs.create_dir('/test/dir1/dir2a') |
| # os.mkdirs() works, too. |
| os.makedirs('/test/dir1/dir2b') |
| self.assertTrue(os.path.isdir('/test/dir1/dir2b')) |
| self.assertTrue(os.path.isdir('/test/dir1/dir2a')) |
| |
| example.rm_tree('/test/dir1') |
| self.assertFalse(os.path.exists('/test/dir1')) |
| |
| def test_os_scandir(self): |
| """Test example.scandir() which uses `os.scandir()`. |
| |
| The os module has been replaced with the fake os module so the |
| fake filesystem path entries are returned instead of `os.DirEntry` |
| objects. |
| """ |
| self.fs.create_file('/test/text.txt') |
| self.fs.create_dir('/test/dir') |
| self.fs.create_file('/linktest/linked') |
| self.fs.create_symlink('/test/linked_file', '/linktest/linked') |
| |
| entries = sorted(example.scan_dir('/test'), key=lambda e: e.name) |
| self.assertEqual(3, len(entries)) |
| self.assertEqual('linked_file', entries[1].name) |
| self.assertTrue(entries[0].is_dir()) |
| self.assertTrue(entries[1].is_symlink()) |
| self.assertTrue(entries[2].is_file()) |
| |
| @unittest.skipIf(not use_scandir_package, |
| 'Testing only if scandir module is installed') |
| def test_scandir_scandir(self): |
| """Test example.scandir() which uses `scandir.scandir()`. |
| |
| The scandir module has been replaced with the fake_scandir module so |
| the fake filesystem path entries are returned instead of |
| `scandir.DirEntry` objects. |
| """ |
| self.fs.create_file('/test/text.txt') |
| self.fs.create_dir('/test/dir') |
| |
| entries = sorted(example.scan_dir('/test'), key=lambda e: e.name) |
| self.assertEqual(2, len(entries)) |
| self.assertEqual('text.txt', entries[1].name) |
| self.assertTrue(entries[0].is_dir()) |
| self.assertTrue(entries[1].is_file()) |
| |
| def test_real_file_access(self): |
| """Test `example.file_contents()` for a real file after adding it using |
| `add_real_file()`.""" |
| with self.assertRaises(OSError): |
| example.file_contents(self.filepath) |
| self.fs.add_real_file(self.filepath) |
| self.assertEqual(example.file_contents(self.filepath), |
| self.real_contents) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
