0x1998 - MANAGER

Düzenlenen Dosya: fake_filesystem_unittest_test.py

# Copyright 2014 Altera Corporation. All Rights Reserved.
# Copyright 2015-2017 John McGehee
# 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.fake_filesystem_unittest.TestCase` base class.
"""
import glob
import io
import multiprocessing
import os
import pathlib
import runpy
import shutil
import sys
import tempfile
import unittest
import warnings
from pathlib import Path
from unittest import TestCase, mock

import pyfakefs.tests.import_as_example
import pyfakefs.tests.logsio
from pyfakefs import fake_filesystem_unittest, fake_filesystem
from pyfakefs.fake_filesystem import OSType
from pyfakefs.fake_filesystem_unittest import (
    Patcher,
    Pause,
    patchfs,
    PatchMode,
)
from pyfakefs.tests.fixtures import module_with_attributes

if sys.version_info < (3, 12):
    # distutils removed in Python 3.12
    from distutils.dir_util import copy_tree, remove_tree

class TestPatcher(TestCase):
    def test_context_manager(self):
        with Patcher() as patcher:
            patcher.fs.create_file("/foo/bar", contents="test")
            with open("/foo/bar") as f:
                contents = f.read()
            self.assertEqual("test", contents)

@patchfs
    def test_context_decorator(self, fake_fs):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar") as f:
            contents = f.read()
        self.assertEqual("test", contents)

class TestPatchfsArgumentOrder(TestCase):
    @patchfs
    @mock.patch("os.system")
    def test_argument_order1(self, fake_fs, patched_system):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar") as f:
            contents = f.read()
        self.assertEqual("test", contents)
        os.system("foo")
        patched_system.assert_called_with("foo")

@mock.patch("os.system")
    @patchfs
    def test_argument_order2(self, patched_system, fake_fs):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar") as f:
            contents = f.read()
        self.assertEqual("test", contents)
        os.system("foo")
        patched_system.assert_called_with("foo")

class TestPyfakefsUnittestBase(fake_filesystem_unittest.TestCase):
    def setUp(self):
        """Set up the fake file system"""
        self.setUpPyfakefs()

class TestPyfakefsUnittest(TestPyfakefsUnittestBase):  # pylint: disable=R0904
    """Test the `pyfakefs.fake_filesystem_unittest.TestCase` base class."""

def test_open(self):
        """Fake `open()` function is bound"""
        self.assertFalse(os.path.exists("/fake_file.txt"))
        with open("/fake_file.txt", "w") as f:
            f.write("This test file was created using the open() function.\n")
        self.assertTrue(self.fs.exists("/fake_file.txt"))
        with open("/fake_file.txt") as f:
            content = f.read()
        self.assertEqual(
            "This test file was created using the " "open() function.\n",
            content,
        )

def test_io_open(self):
        """Fake io module is bound"""
        self.assertFalse(os.path.exists("/fake_file.txt"))
        with io.open("/fake_file.txt", "w") as f:
            f.write("This test file was created using the" " io.open() function.\n")
        self.assertTrue(self.fs.exists("/fake_file.txt"))
        with open("/fake_file.txt") as f:
            content = f.read()
        self.assertEqual(
            "This test file was created using the " "io.open() function.\n",
            content,
        )

def test_os(self):
        """Fake os module is bound"""
        self.assertFalse(self.fs.exists("/test/dir1/dir2"))
        os.makedirs("/test/dir1/dir2")
        self.assertTrue(self.fs.exists("/test/dir1/dir2"))

def test_glob(self):
        """Fake glob module is bound"""
        is_windows = sys.platform.startswith("win")
        self.assertEqual([], glob.glob("/test/dir1/dir*"))
        self.fs.create_dir("/test/dir1/dir2a")
        matching_paths = glob.glob("/test/dir1/dir*")
        if is_windows:
            self.assertEqual([r"/test/dir1\dir2a"], matching_paths)
        else:
            self.assertEqual(["/test/dir1/dir2a"], matching_paths)
        self.fs.create_dir("/test/dir1/dir2b")
        matching_paths = sorted(glob.glob("/test/dir1/dir*"))
        if is_windows:
            self.assertEqual([r"/test/dir1\dir2a", r"/test/dir1\dir2b"], matching_paths)
        else:
            self.assertEqual(["/test/dir1/dir2a", "/test/dir1/dir2b"], matching_paths)

def test_shutil(self):
        """Fake shutil module is bound"""
        self.fs.create_dir("/test/dir1/dir2a")
        self.fs.create_dir("/test/dir1/dir2b")
        self.assertTrue(self.fs.exists("/test/dir1/dir2b"))
        self.assertTrue(self.fs.exists("/test/dir1/dir2a"))

shutil.rmtree("/test/dir1")
        self.assertFalse(self.fs.exists("/test/dir1"))

def test_fakepathlib(self):
        p = pathlib.Path("/fake_file.txt")
        with p.open("w") as f:
            f.write("text")
        is_windows = sys.platform.startswith("win")
        if is_windows:
            self.assertTrue(self.fs.exists(r"\fake_file.txt"))
        else:
            self.assertTrue(self.fs.exists("/fake_file.txt"))

class TestPatchingImports(TestPyfakefsUnittestBase):
    def test_import_as_other_name(self):
        file_path = "/foo/bar/baz"
        self.fs.create_file(file_path)
        self.assertTrue(self.fs.exists(file_path))
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1(file_path))

def test_import_path_from_os(self):
        """Make sure `from os import path` patches `path`."""
        file_path = "/foo/bar/baz"
        self.fs.create_file(file_path)
        self.assertTrue(self.fs.exists(file_path))
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2(file_path))

def test_import_path_from_pathlib(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3(file_path))

def test_import_exists_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5(file_path))

def test_import_isfile_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_isfile(file_path))

def test_import_isdir_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_isdir(file_path))

def test_import_islink_from_os_path(self):
        file_path = "/foo/bar"
        link_path = "/foo/link"
        self.fs.create_file(file_path)
        self.fs.create_symlink(link_path, file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_islink(link_path))

def test_import_function_from_os_path_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6(file_path))

def test_import_pathlib_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7(file_path))

def test_import_function_from_os(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        stat_result = pyfakefs.tests.import_as_example.file_stat1(file_path)
        self.assertEqual(3, stat_result.st_size)

def test_import_function_from_os_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        stat_result = pyfakefs.tests.import_as_example.file_stat2(file_path)
        self.assertEqual(3, stat_result.st_size)

@unittest.skipIf(sys.version_info >= (3, 12), "Currently not working in 3.12")
    def test_import_open_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.import_as_example.file_contents1(file_path)
        self.assertEqual("abc", contents)

@unittest.skipIf(sys.version_info >= (3, 12), "Currently not working in 3.12")
    def test_import_io_open_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.import_as_example.file_contents2(file_path)
        self.assertEqual("abc", contents)

class TestPatchingDefaultArgs(fake_filesystem_unittest.TestCase):
    def setUp(self):
        self.setUpPyfakefs(patch_default_args=True)

def test_path_exists_as_default_arg_in_function(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4(file_path))

def test_path_exists_as_default_arg_in_method(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        sut = pyfakefs.tests.import_as_example.TestDefaultArg()
        self.assertTrue(sut.check_if_exists(file_path))

def test_fake_path_exists4(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4("foo"))

class TestAttributesWithFakeModuleNames(TestPyfakefsUnittestBase):
    """Test that module attributes with names like `path` or `io` are not
    stubbed out.
    """

def test_attributes(self):
        """Attributes of module under test are not patched"""
        self.assertEqual(module_with_attributes.os, "os attribute value")
        self.assertEqual(module_with_attributes.path, "path attribute value")
        self.assertEqual(module_with_attributes.pathlib, "pathlib attribute value")
        self.assertEqual(module_with_attributes.shutil, "shutil attribute value")
        self.assertEqual(module_with_attributes.io, "io attribute value")

import math as path  # noqa: E402 wanted import not at top

class TestPathNotPatchedIfNotOsPath(TestPyfakefsUnittestBase):
    """Tests that `path` is not patched if it is not `os.path`.
    An own path module (in this case an alias to math) can be imported
    and used.
    """

def test_own_path_module(self):
        self.assertEqual(2, path.floor(2.5))

class FailedPatchingTest(TestPyfakefsUnittestBase):
    """Negative tests: make sure the tests for `modules_to_reload` and
    `modules_to_patch` fail if not providing the arguments.
    """

@unittest.expectedFailure
    def test_system_stat(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"test")
        self.assertEqual(
            4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size
        )

class ReloadModuleTest(fake_filesystem_unittest.TestCase):
    """Make sure that reloading a module allows patching of classes not
    patched automatically.
    """

def setUp(self):
        """Set up the fake file system"""
        self.setUpPyfakefs(modules_to_reload=[pyfakefs.tests.import_as_example])

class NoSkipNamesTest(fake_filesystem_unittest.TestCase):
    """Reference test for additional_skip_names tests:
    make sure that the module is patched by default."""

def setUp(self):
        self.setUpPyfakefs()

def test_path_exists(self):
        self.assertFalse(pyfakefs.tests.import_as_example.exists_this_file())

def test_fake_path_exists1(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1("foo"))

def test_fake_path_exists2(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2("foo"))

def test_fake_path_exists3(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3("foo"))

def test_fake_path_exists5(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5("foo"))

def test_fake_path_exists6(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6("foo"))

def test_fake_path_exists7(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7("foo"))

def test_open_fails(self):
        with self.assertRaises(OSError):
            pyfakefs.tests.import_as_example.open_this_file()

def test_open_patched_in_module_ending_with_io(self):
        # regression test for #569
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.logsio.file_contents(file_path)
        self.assertEqual(b"abc", contents)

class AdditionalSkipNamesTest(fake_filesystem_unittest.TestCase):
    """Make sure that modules in additional_skip_names are not patched.
    Passes module name to `additional_skip_names`."""

def setUp(self):
        self.setUpPyfakefs(additional_skip_names=["pyfakefs.tests.import_as_example"])

def test_path_exists(self):
        self.assertTrue(pyfakefs.tests.import_as_example.exists_this_file())

def test_fake_path_does_not_exist1(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists1("foo"))

def test_fake_path_does_not_exist2(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists2("foo"))

def test_fake_path_does_not_exist3(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists3("foo"))

def test_fake_path_does_not_exist4(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists4("foo"))

def test_fake_path_does_not_exist5(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists5("foo"))

def test_fake_path_does_not_exist6(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists6("foo"))

def test_fake_path_does_not_exist7(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists7("foo"))

@unittest.skipIf(
        sys.version_info >= (3, 12),
        "Skip modules currently not working for open in 3.12",
    )
    def test_open_succeeds(self):
        pyfakefs.tests.import_as_example.open_this_file()

def test_path_succeeds(self):
        pyfakefs.tests.import_as_example.return_this_file_path()

class AdditionalSkipNamesModuleTest(fake_filesystem_unittest.TestCase):
    """Make sure that modules in additional_skip_names are not patched.
    Passes module to `additional_skip_names`."""

def setUp(self):
        self.setUpPyfakefs(additional_skip_names=[pyfakefs.tests.import_as_example])