IPython/nbconvert/writers/tests/test_files.py

"""
Module with tests for files
"""

#-----------------------------------------------------------------------------
# Copyright (c) 2013, the IPython Development Team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------

import sys
import os

from ...tests.base import TestsBase
from ..files import FilesWriter
from IPython.utils.py3compat import PY3

if PY3:
    from io import StringIO
else:
    from StringIO import StringIO


#-----------------------------------------------------------------------------
# Class
#-----------------------------------------------------------------------------

class Testfiles(TestsBase):
    """Contains test functions for files.py"""

    def test_basic_output(self):
        """Is FilesWriter basic output correct?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create the resoruces dictionary
            res = {}

            # Create files writer, test output
            writer = FilesWriter()
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            with open('z', 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

    def test_ext(self):
        """Does the FilesWriter add the correct extension to the output?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create the resoruces dictionary
            res = {'output_extension': '.txt'}

            # Create files writer, test output
            writer = FilesWriter()
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isfile('z.txt')
            with open('z.txt', 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')


    def test_extract(self):
        """Can FilesWriter write extracted figures correctly?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create the resoruces dictionary
            res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}

            # Create files writer, test output
            writer = FilesWriter()
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            with open('z', 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check the output of the extracted file
            extracted_file_dest = os.path.join('z_files', 'a')
            assert os.path.isfile(extracted_file_dest)
            with open(extracted_file_dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'b')


    def test_builddir(self):
        """Can FilesWriter write to a build dir correctly?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create the resoruces dictionary
            res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}

            # Create files writer, test output
            writer = FilesWriter()
            writer.build_directory = u'build'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check the output of the extracted file
            extracted_file_dest = os.path.join(writer.build_directory, 'z_files', 'a')
            assert os.path.isfile(extracted_file_dest)
            with open(extracted_file_dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'b')


    def test_links(self):
        """Can the FilesWriter handle linked files correctly?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create test file
            os.mkdir('sub')
            with open(os.path.join('sub', 'c'), 'w') as f:
                f.write('d')

            # Create the resoruces dictionary
            res = {}

            # Create files writer, test output
            writer = FilesWriter()
            writer.files = [os.path.join('sub', 'c')]
            writer.build_directory = u'build'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check to make sure the linked file was copied
            path = os.path.join(writer.build_directory, 'sub')
            assert os.path.isdir(path)
            dest = os.path.join(path, 'c')
            assert os.path.isfile(dest)
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'd')

    def test_glob(self):
        """Can the FilesWriter handle globbed files correctly?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create test files
            os.mkdir('sub')
            with open(os.path.join('sub', 'c'), 'w') as f:
                f.write('e')
            with open(os.path.join('sub', 'd'), 'w') as f:
                f.write('e')

            # Create the resoruces dictionary
            res = {}

            # Create files writer, test output
            writer = FilesWriter()
            writer.files = ['sub/*']
            writer.build_directory = u'build'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check to make sure the globbed files were copied
            path = os.path.join(writer.build_directory, 'sub')
            assert os.path.isdir(path)
            for filename in ['c', 'd']:
                dest = os.path.join(path, filename)
                assert os.path.isfile(dest)
                with open(dest, 'r') as f:
                    output = f.read()
                    self.assertEqual(output, 'e')

    def test_relpath(self):
        """Can the FilesWriter handle relative paths for linked files correctly?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create test file
            os.mkdir('sub')
            with open(os.path.join('sub', 'c'), 'w') as f:
                f.write('d')

            # Create the resoruces dictionary
            res = {}

            # Create files writer, test output
            writer = FilesWriter()
            writer.files = [os.path.join('sub', 'c')]
            writer.build_directory = u'build'
            writer.relpath = 'sub'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check to make sure the linked file was copied
            dest = os.path.join(writer.build_directory, 'c')
            assert os.path.isfile(dest)
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'd')

    def test_relpath_default(self):
        """Is the FilesWriter default relative path correct?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create test file
            os.mkdir('sub')
            with open(os.path.join('sub', 'c'), 'w') as f:
                f.write('d')

            # Create the resoruces dictionary
            res = dict(metadata=dict(path="sub"))

            # Create files writer, test output
            writer = FilesWriter()
            writer.files = [os.path.join('sub', 'c')]
            writer.build_directory = u'build'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check to make sure the linked file was copied
            dest = os.path.join(writer.build_directory, 'c')
            assert os.path.isfile(dest)
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'd')

    def test_relpath_default(self):
        """Does the FilesWriter relpath option take precedence over the path?"""

        # Work in a temporary directory.
        with self.create_temp_cwd():

            # Create test file
            os.mkdir('sub')
            with open(os.path.join('sub', 'c'), 'w') as f:
                f.write('d')

            # Create the resoruces dictionary
            res = dict(metadata=dict(path="other_sub"))

            # Create files writer, test output
            writer = FilesWriter()
            writer.files = [os.path.join('sub', 'c')]
            writer.build_directory = u'build'
            writer.relpath = 'sub'
            writer.write(u'y', res, notebook_name="z")

            # Check the output of the file
            assert os.path.isdir(writer.build_directory)
            dest = os.path.join(writer.build_directory, 'z')
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, u'y')

            # Check to make sure the linked file was copied
            dest = os.path.join(writer.build_directory, 'c')
            assert os.path.isfile(dest)
            with open(dest, 'r') as f:
                output = f.read()
                self.assertEqual(output, 'd')