# Copyright 2009 Google Inc. All Rights Reserved.
#
# 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 that FakeFilesystem calls work identically to a real filesystem."""
# pylint: disable-all

import os
import shutil
import sys
import tempfile
import time
import unittest

from pyfakefs import fake_filesystem


def sep(path):
    """Converts slashes in the path to the architecture's path seperator."""
    if isinstance(path, str):
        return path.replace('/', os.sep)
    return path


def _get_errno(raised_error):
    if raised_error is not None:
        try:
            return raised_error.errno
        except AttributeError:
            pass


class TestCase(unittest.TestCase):
    is_windows = sys.platform.startswith('win')
    _FAKE_FS_BASE = sep('/fakefs')


class FakeFilesystemVsRealTest(TestCase):
    def _paths(self, path):
        """For a given path, return paths in the real and fake filesystems."""
        if not path:
            return None, None
        return (os.path.join(self.real_base, path),
                os.path.join(self.fake_base, path))

    def _create_test_file(self, file_type, path, contents=None):
        """Create a dir, file, or link in both the real fs and the fake."""
        path = sep(path)
        self._created_files.append([file_type, path, contents])
        real_path, fake_path = self._paths(path)
        if file_type == 'd':
            os.mkdir(real_path)
            self.fake_os.mkdir(fake_path)
        if file_type == 'f':
            fh = open(real_path, 'w')
            fh.write(contents or '')
            fh.close()
            fh = self.fake_open(fake_path, 'w')
            fh.write(contents or '')
            fh.close()
        # b for binary file
        if file_type == 'b':
            fh = open(real_path, 'wb')
            fh.write(contents or '')
            fh.close()
            fh = self.fake_open(fake_path, 'wb')
            fh.write(contents or '')
            fh.close()
        # l for symlink, h for hard link
        if file_type in ('l', 'h'):
            real_target, fake_target = (contents, contents)
            # If it begins with '/', make it relative to the base. You can't go
            # creating files in / for the real file system.
            if contents.startswith(os.sep):
                real_target, fake_target = self._paths(contents[1:])
            if file_type == 'l':
                os.symlink(real_target, real_path)
                self.fake_os.symlink(fake_target, fake_path)
            elif file_type == 'h':
                os.link(real_target, real_path)
                self.fake_os.link(fake_target, fake_path)

    def setUp(self):
        # Base paths in the real and test file systems. We keep them different
        # so that missing features in the fake don't fall through to the base
        # operations and magically succeed.
        tsname = 'fakefs.%s' % time.time()
        self.cwd = os.getcwd()
        # Fully expand the base_path - required on OS X.
        self.real_base = os.path.realpath(
            os.path.join(tempfile.gettempdir(), tsname))
        os.chdir(tempfile.gettempdir())
        if os.path.isdir(self.real_base):
            shutil.rmtree(self.real_base)
        os.mkdir(self.real_base)
        self.fake_base = self._FAKE_FS_BASE

        # Make sure we can write to the physical testing temp directory.
        self.assertTrue(os.access(self.real_base, os.W_OK))

        self.fake_filesystem = fake_filesystem.FakeFilesystem()
        self.fake_filesystem.create_dir(self.fake_base)
        self.fake_os = fake_filesystem.FakeOsModule(self.fake_filesystem)
        self.fake_open = fake_filesystem.FakeFileOpen(self.fake_filesystem)
        self._created_files = []

        os.chdir(self.real_base)
        self.fake_os.chdir(self.fake_base)

    def tearDown(self):
        # We have to remove all the files from the real FS. Doing the same for
        # the fake FS is optional, but doing it is an extra sanity check.
        os.chdir(tempfile.gettempdir())
        try:
            rev_files = self._created_files[:]
            rev_files.reverse()
            for info in rev_files:
                real_path, fake_path = self._paths(info[1])
                if info[0] == 'd':
                    try:
                        os.rmdir(real_path)
                    except OSError as e:
                        if 'Directory not empty' in e:
                            self.fail('Real path %s not empty: %s : %s' % (
                                real_path, e, os.listdir(real_path)))
                        else:
                            raise
                    self.fake_os.rmdir(fake_path)
                if info[0] == 'f' or info[0] == 'l':
                    os.remove(real_path)
                    self.fake_os.remove(fake_path)
        finally:
            shutil.rmtree(self.real_base)
            os.chdir(self.cwd)

    def _compare_behaviors(self, method_name, path, real, fake,
                           method_returns_path=False):
        """Invoke an os method in both real and fake contexts and compare
        results.

        Invoke a real filesystem method with a path to a real file and invoke
        a fake filesystem method with a path to a fake file and compare the
        results. We expect some calls to throw Exceptions, so we catch those
        and compare them.

        Args:
            method_name: Name of method being tested, for use in
                error messages.
            path: potential path to a file in the real and fake file systems,
                passing an empty tuple indicates that no arguments to pass
                to method.
            real: built-in system library or method from the built-in system
                library which takes a path as an arg and returns some value.
            fake: fake_filsystem object or method from a fake_filesystem class
                which takes a path as an arg and returns some value.
            method_returns_path: True if the method returns a path, and thus we
                must compensate for expected difference between real and fake.

        Returns:
            A description of the difference in behavior, or None.
        """
        # pylint: disable=C6403

        def _error_class(exc):
            if exc:
                if hasattr(exc, 'errno'):
                    return '{}({})'.format(exc.__class__.__name__, exc.errno)
                return exc.__class__.__name__
            return 'None'

        real_err, real_value = self._get_real_value(method_name, path, real)
        fake_err, fake_value = self._get_fake_value(method_name, path, fake)

        method_call = '%s' % method_name
        method_call += '()' if path == () else '(%s)' % path
        # We only compare on the error class because the acutal error contents
        # is almost always different because of the file paths.
        if _error_class(real_err) != _error_class(fake_err):
            if real_err is None:
                return '%s: real version returned %s, fake raised %s' % (
                    method_call, real_value, _error_class(fake_err))
            if fake_err is None:
                return '%s: real version raised %s, fake returned %s' % (
                    method_call, _error_class(real_err), fake_value)
            return '%s: real version raised %s, fake raised %s' % (
                method_call, _error_class(real_err), _error_class(fake_err))
        real_errno = _get_errno(real_err)
        fake_errno = _get_errno(fake_err)
        if real_errno != fake_errno:
            return '%s(%s): both raised %s, real errno %s, fake errno %s' % (
                method_name, path, _error_class(real_err),
                real_errno, fake_errno)
        # If the method is supposed to return a full path AND both values
        # begin with the expected full path, then trim it off.
        if method_returns_path:
            if (real_value and fake_value
                    and real_value.startswith(self.real_base)
                    and fake_value.startswith(self.fake_base)):
                real_value = real_value[len(self.real_base):]
                fake_value = fake_value[len(self.fake_base):]
        if real_value != fake_value:
            return '%s: real return %s, fake returned %s' % (
                method_call, real_value, fake_value)
        return None

    @staticmethod
    def _get_fake_value(method_name, path, fake):
        fake_value = None
        fake_err = None
        try:
            fake_method = fake
            if not callable(fake):
                fake_method = getattr(fake, method_name)
            args = [] if path == () else [path]
            fake_value = str(fake_method(*args))
        except Exception as e:  # pylint: disable-msg=W0703
            fake_err = e
        return fake_err, fake_value

    @staticmethod
    def _get_real_value(method_name, path, real):
        real_value = None
        real_err = None
        # Catching Exception below gives a lint warning, but it's what we need.
        try:
            args = [] if path == () else [path]
            real_method = real
            if not callable(real):
                real_method = getattr(real, method_name)
            real_value = str(real_method(*args))
        except Exception as e:  # pylint: disable-msg=W0703
            real_err = e
        return real_err, real_value

    def assertOsMethodBehaviorMatches(self, method_name, path,
                                      method_returns_path=False):
        """Invoke an os method in both real and fake contexts and compare.

        For a given method name (from the os module) and a path, compare the
        behavior of the system provided module against the fake_filesystem
        module.
        We expect results and/or Exceptions raised to be identical.

        Args:
            method_name: Name of method being tested.
            path: potential path to a file in the real and fake file systems.
            method_returns_path: True if the method returns a path, and thus we
                must compensate for expected difference between real and fake.

        Returns:
            A description of the difference in behavior, or None.
        """
        path = sep(path)
        return self._compare_behaviors(method_name, path, os, self.fake_os,
                                       method_returns_path)

    def diff_open_method_behavior(self, method_name, path, mode, data,
                                  method_returns_data=True):
        """Invoke an open method in both real and fkae contexts and compare.

        Args:
            method_name: Name of method being tested.
            path: potential path to a file in the real and fake file systems.
            mode: how to open the file.
            data: any data to pass to the method.
            method_returns_data: True if a method returns some sort of data.

        For a given method name (from builtin open) and a path, compare the
        behavior of the system provided module against the fake_filesystem
        module.
        We expect results and/or Exceptions raised to be identical.

        Returns:
            A description of the difference in behavior, or None.
        """
        with open(path, mode) as real_fh:
            with self.fake_open(path, mode) as fake_fh:
                return self._compare_behaviors(
                    method_name, data, real_fh, fake_fh, method_returns_data)

    def diff_os_path_method_behavior(self, method_name, path,
                                     method_returns_path=False):
        """Invoke an os.path method in both real and fake contexts and compare.

        For a given method name (from the os.path module) and a path, compare
        the behavior of the system provided module against the
        fake_filesytem module.
        We expect results and/or Exceptions raised to be identical.

        Args:
            method_name: Name of method being tested.
            path: potential path to a file in the real and fake file systems.
            method_returns_path: True if the method returns a path, and thus we
                must compensate for expected difference between real and fake.

        Returns:
            A description of the difference in behavior, or None.
        """
        return self._compare_behaviors(method_name, path, os.path,
                                       self.fake_os.path,
                                       method_returns_path)

    def assertOsPathMethodBehaviorMatches(self, method_name, path,
                                          method_returns_path=False):
        """Assert that an os.path behaves the same in both real and
        fake contexts.

        Wraps DiffOsPathMethodBehavior, raising AssertionError if any
        differences are reported.

        Args:
            method_name: Name of method being tested.
            path: potential path to a file in the real and fake file systems.
            method_returns_path: True if the method returns a path, and thus we
                must compensate for expected difference between real and fake.

        Raises:
            AssertionError if there is any difference in behavior.
        """
        path = sep(path)
        diff = self.diff_os_path_method_behavior(
            method_name, path, method_returns_path)
        if diff:
            self.fail(diff)

    def assertAllOsBehaviorsMatch(self, path):
        path = sep(path)
        os_method_names = [] if self.is_windows else ['readlink']
        os_method_names_no_args = ['getcwd']
        os_path_method_names = ['isabs',
                                'isdir',
                                'isfile',
                                'exists'
                                ]
        if not self.is_windows:
            os_path_method_names.append('islink')
            os_path_method_names.append('lexists')
        wrapped_methods = [
            ['access', self._access_real, self._access_fake],
            ['stat.size', self._stat_size_real, self._stat_size_fake],
            ['lstat.size', self._lstat_size_real, self._lstat_size_fake]
        ]

        differences = []
        for method_name in os_method_names:
            diff = self.assertOsMethodBehaviorMatches(method_name, path)
            if diff:
                differences.append(diff)
        for method_name in os_method_names_no_args:
            diff = self.assertOsMethodBehaviorMatches(method_name, (),
                                                      method_returns_path=True)
            if diff:
                differences.append(diff)
        for method_name in os_path_method_names:
            diff = self.diff_os_path_method_behavior(method_name, path)
            if diff:
                differences.append(diff)
        for m in wrapped_methods:
            diff = self._compare_behaviors(m[0], path, m[1], m[2])
            if diff:
                differences.append(diff)
        if differences:
            self.fail('Behaviors do not match for %s:\n    %s' %
                      (path, '\n    '.join(differences)))

    def assertFileHandleBehaviorsMatch(self, path, mode, data):
        path = sep(path)
        write_method_names = ['write', 'writelines']
        read_method_names = ['read', 'readlines']
        other_method_names = ['truncate', 'flush', 'close']
        differences = []
        for method_name in write_method_names:
            diff = self.diff_open_method_behavior(
                method_name, path, mode, data)
            if diff:
                differences.append(diff)
        for method_name in read_method_names + other_method_names:
            diff = self.diff_open_method_behavior(method_name, path, mode, ())
            if diff:
                differences.append(diff)
        if differences:
            self.fail('Behaviors do not match for %s:\n    %s' %
                      (path, '\n    '.join(differences)))

    # Helpers for checks which are not straight method calls.
    @staticmethod
    def _access_real(path):
        return os.access(path, os.R_OK)

    def _access_fake(self, path):
        return self.fake_os.access(path, os.R_OK)

    def _stat_size_real(self, path):
        real_path, unused_fake_path = self._paths(path)
        # fake_filesystem.py does not implement stat().st_size for directories
        if os.path.isdir(real_path):
            return None
        return os.stat(real_path).st_size

    def _stat_size_fake(self, path):
        unused_real_path, fake_path = self._paths(path)
        # fake_filesystem.py does not implement stat().st_size for directories
        if self.fake_os.path.isdir(fake_path):
            return None
        return self.fake_os.stat(fake_path).st_size

    def _lstat_size_real(self, path):
        real_path, unused_fake_path = self._paths(path)
        if os.path.isdir(real_path):
            return None
        size = os.lstat(real_path).st_size
        # Account for the difference in the lengths of the absolute paths.
        if os.path.islink(real_path):
            if os.readlink(real_path).startswith(os.sep):
                size -= len(self.real_base)
        return size

    def _lstat_size_fake(self, path):
        unused_real_path, fake_path = self._paths(path)
        # size = 0
        if self.fake_os.path.isdir(fake_path):
            return None
        size = self.fake_os.lstat(fake_path).st_size
        # Account for the difference in the lengths of the absolute paths.
        if self.fake_os.path.islink(fake_path):
            if self.fake_os.readlink(fake_path).startswith(os.sep):
                size -= len(self.fake_base)
        return size

    def test_isabs(self):
        # We do not have to create any files for isabs.
        self.assertOsPathMethodBehaviorMatches('isabs', None)
        self.assertOsPathMethodBehaviorMatches('isabs', '')
        self.assertOsPathMethodBehaviorMatches('isabs', '/')
        self.assertOsPathMethodBehaviorMatches('isabs', '/a')
        self.assertOsPathMethodBehaviorMatches('isabs', 'a')

    def test_none_path(self):
        self.assertAllOsBehaviorsMatch(None)

    def test_empty_path(self):
        self.assertAllOsBehaviorsMatch('')

    def test_root_path(self):
        self.assertAllOsBehaviorsMatch('/')

    def test_non_existant_file(self):
        self.assertAllOsBehaviorsMatch('foo')

    def test_empty_file(self):
        self._create_test_file('f', 'aFile')
        self.assertAllOsBehaviorsMatch('aFile')

    def test_file_with_contents(self):
        self._create_test_file('f', 'aFile', 'some contents')
        self.assertAllOsBehaviorsMatch('aFile')

    def test_file_with_binary_contents(self):
        self._create_test_file('b', 'aFile', b'some contents')
        self.assertAllOsBehaviorsMatch('aFile')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_sym_link_to_empty_file(self):
        self._create_test_file('f', 'aFile')
        self._create_test_file('l', 'link_to_empty', 'aFile')
        self.assertAllOsBehaviorsMatch('link_to_empty')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_hard_link_to_empty_file(self):
        self._create_test_file('f', 'aFile')
        self._create_test_file('h', 'link_to_empty', 'aFile')
        self.assertAllOsBehaviorsMatch('link_to_empty')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_sym_link_to_real_file(self):
        self._create_test_file('f', 'aFile', 'some contents')
        self._create_test_file('l', 'link_to_file', 'aFile')
        self.assertAllOsBehaviorsMatch('link_to_file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_hard_link_to_real_file(self):
        self._create_test_file('f', 'aFile', 'some contents')
        self._create_test_file('h', 'link_to_file', 'aFile')
        self.assertAllOsBehaviorsMatch('link_to_file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_broken_sym_link(self):
        self._create_test_file('l', 'broken_link', 'broken')
        self._create_test_file('l', 'loop', '/a/loop')
        self.assertAllOsBehaviorsMatch('broken_link')

    def test_file_in_a_folder(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('f', 'a/b/file', 'contents')
        self.assertAllOsBehaviorsMatch('a/b/file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_absolute_sym_link_to_folder(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('f', 'a/b/file', 'contents')
        self._create_test_file('l', 'a/link', '/a/b')
        self.assertAllOsBehaviorsMatch('a/link/file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_link_to_folder_after_chdir(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('f', 'a/b/file', 'contents')
        self._create_test_file('l', 'a/link', '/a/b')

        real_dir, fake_dir = self._paths('a/b')
        os.chdir(real_dir)
        self.fake_os.chdir(fake_dir)
        self.assertAllOsBehaviorsMatch('file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_relative_sym_link_to_folder(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('f', 'a/b/file', 'contents')
        self._create_test_file('l', 'a/link', 'b')
        self.assertAllOsBehaviorsMatch('a/link/file')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_sym_link_to_parent(self):
        # Soft links on HFS+ / OS X behave differently.
        if os.uname()[0] != 'Darwin':
            self._create_test_file('d', 'a')
            self._create_test_file('d', 'a/b')
            self._create_test_file('l', 'a/b/c', '..')
            self.assertAllOsBehaviorsMatch('a/b/c')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_path_through_sym_link_to_parent(self):
        self._create_test_file('d', 'a')
        self._create_test_file('f', 'a/target', 'contents')
        self._create_test_file('d', 'a/b')
        self._create_test_file('l', 'a/b/c', '..')
        self.assertAllOsBehaviorsMatch('a/b/c/target')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_sym_link_to_sibling_directory(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self._create_test_file('l', 'a/b/c', '../sibling_of_b')
        self.assertAllOsBehaviorsMatch('a/b/c/target')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_sym_link_to_sibling_directory_non_existant_file(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self._create_test_file('l', 'a/b/c', '../sibling_of_b')
        self.assertAllOsBehaviorsMatch('a/b/c/file_does_not_exist')

    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
    def test_broken_sym_link_to_sibling_directory(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self._create_test_file('l', 'a/b/c', '../broken_sibling_of_b')
        self.assertAllOsBehaviorsMatch('a/b/c/target')

    def test_relative_path(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self.assertAllOsBehaviorsMatch('a/b/../sibling_of_b/target')

    def test_broken_relative_path(self):
        self._create_test_file('d', 'a')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self.assertAllOsBehaviorsMatch('a/b/../broken/target')

    def test_bad_relative_path(self):
        self._create_test_file('d', 'a')
        self._create_test_file('f', 'a/target', 'contents')
        self._create_test_file('d', 'a/b')
        self._create_test_file('d', 'a/sibling_of_b')
        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
        self.assertAllOsBehaviorsMatch('a/b/../broken/../target')

    def test_getmtime_nonexistant_path(self):
        self.assertOsPathMethodBehaviorMatches('getmtime', 'no/such/path')

    def test_builtin_open_modes(self):
        self._create_test_file('f', 'read', 'some contents')
        self._create_test_file('f', 'write', 'some contents')
        self._create_test_file('f', 'append', 'some contents')
        self.assertFileHandleBehaviorsMatch('read', 'r', 'other contents')
        self.assertFileHandleBehaviorsMatch('write', 'w', 'other contents')
        self.assertFileHandleBehaviorsMatch('append', 'a', 'other contents')
        self._create_test_file('f', 'readplus', 'some contents')
        self._create_test_file('f', 'writeplus', 'some contents')
        self.assertFileHandleBehaviorsMatch(
            'readplus', 'r+', 'other contents')
        self.assertFileHandleBehaviorsMatch(
            'writeplus', 'w+', 'other contents')
        self._create_test_file('b', 'binaryread', b'some contents')
        self._create_test_file('b', 'binarywrite', b'some contents')
        self._create_test_file('b', 'binaryappend', b'some contents')
        self.assertFileHandleBehaviorsMatch(
            'binaryread', 'rb', b'other contents')
        self.assertFileHandleBehaviorsMatch(
            'binarywrite', 'wb', b'other contents')
        self.assertFileHandleBehaviorsMatch(
            'binaryappend', 'ab', b'other contents')
        self.assertFileHandleBehaviorsMatch('read', 'rb', 'other contents')
        self.assertFileHandleBehaviorsMatch('write', 'wb', 'other contents')
        self.assertFileHandleBehaviorsMatch('append', 'ab', 'other contents')


def main(_):
    unittest.main()


if __name__ == '__main__':
    unittest.main()
