Na}{

File Content: `example_test.py`

# 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.legacy_packages import scandir
from pyfakefs.tests import example  # The module under test


# Work around pyupgrade auto-rewriting `io.open()` to `open()`.
io_open = io.open


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\nSecond 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(scandir is None, "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()

Name	Size	Permission
__pycache__	---	0755
fixtures	---	0755
__init__.py	0 bytes	0644
all_tests.py	2602 bytes	0644
all_tests_without_extra_packages.py	993 bytes	0644
dynamic_patch_test.py	2083 bytes	0644
example.py	4003 bytes	0644
example_test.py	7002 bytes	0644
fake_filesystem_glob_test.py	2821 bytes	0644
fake_filesystem_shutil_test.py	23897 bytes	0644
fake_filesystem_test.py	113311 bytes	0644
fake_filesystem_unittest_test.py	39720 bytes	0644
fake_filesystem_vs_real_test.py	30696 bytes	0644
fake_legacy_modules_test.py	3744 bytes	0644
fake_open_test.py	91200 bytes	0644
fake_os_test.py	244792 bytes	0644
fake_pathlib_test.py	71892 bytes	0644
fake_stat_time_test.py	22353 bytes	0644
fake_tempfile_test.py	4199 bytes	0644
import_as_example.py	3235 bytes	0644
logsio.py	832 bytes	0644
mox3_stubout_example.py	893 bytes	0644
mox3_stubout_test.py	5336 bytes	0644
patched_packages_test.py	2570 bytes	0644
performance_test.py	2622 bytes	0644
skipped_pathlib.py	1211 bytes	0644
test_utils.py	16442 bytes	0644

File Content: example_test.py

File Content: `example_test.py`