diff options
Diffstat (limited to 'tests/test_scaffolds/test_copydir.py')
| -rw-r--r-- | tests/test_scaffolds/test_copydir.py | 454 |
1 files changed, 454 insertions, 0 deletions
diff --git a/tests/test_scaffolds/test_copydir.py b/tests/test_scaffolds/test_copydir.py new file mode 100644 index 000000000..915cc5033 --- /dev/null +++ b/tests/test_scaffolds/test_copydir.py @@ -0,0 +1,454 @@ +# -*- coding: utf-8 -*- +import unittest +import os +import pkg_resources + +class Test_copy_dir(unittest.TestCase): + def setUp(self): + import tempfile + from pyramid.compat import NativeIO + self.dirname = tempfile.mkdtemp() + self.out = NativeIO() + self.fixturetuple = ('tests.test_scaffolds', + 'fixture_scaffold') + + def tearDown(self): + import shutil + shutil.rmtree(self.dirname, ignore_errors=True) + self.out.close() + + def _callFUT(self, *arg, **kw): + kw['out_'] = self.out + from pyramid.scaffolds.copydir import copy_dir + return copy_dir(*arg, **kw) + + def test_copy_source_as_pkg_resource(self): + vars = {'package':'mypackage'} + self._callFUT(self.fixturetuple, + self.dirname, + vars, + 1, False, + template_renderer=dummy_template_renderer) + result = self.out.getvalue() + self.assertTrue('Creating' in result) + self.assertTrue( + 'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result) + source = pkg_resources.resource_filename( + 'tests.test_scaffolds', + 'fixture_scaffold/+package+/__init__.py_tmpl') + target = os.path.join(self.dirname, 'mypackage', '__init__.py') + with open(target, 'r') as f: + tcontent = f.read() + with open(source, 'r') as f: + scontent = f.read() + self.assertEqual(scontent, tcontent) + + def test_copy_source_as_dirname(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + self._callFUT(source, + self.dirname, + vars, + 1, False, + template_renderer=dummy_template_renderer) + result = self.out.getvalue() + self.assertTrue('Creating' in result) + self.assertTrue('Copying __init__.py_tmpl to' in result) + source = pkg_resources.resource_filename( + 'tests.test_scaffolds', + 'fixture_scaffold/+package+/__init__.py_tmpl') + target = os.path.join(self.dirname, 'mypackage', '__init__.py') + with open(target, 'r') as f: + tcontent = f.read() + with open(source, 'r') as f: + scontent = f.read() + self.assertEqual(scontent, tcontent) + + def test_content_is_same_message(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + self._callFUT(source, + self.dirname, + vars, + 2, False, + template_renderer=dummy_template_renderer) + self._callFUT(source, + self.dirname, + vars, + 2, False, + template_renderer=dummy_template_renderer) + result = self.out.getvalue() + self.assertTrue('%s already exists (same content)' % \ + os.path.join(self.dirname, 'mypackage', '__init__.py') in result) + + def test_direxists_message(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + # if not os.path.exists(self.dirname): + # os.mkdir(self.dirname) + self._callFUT(source, + self.dirname, + vars, + 2, False, + template_renderer=dummy_template_renderer) + result = self.out.getvalue() + self.assertTrue('Directory %s exists' % self.dirname in result, result) + + def test_overwrite_false(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + self._callFUT(source, + self.dirname, + vars, + 1, False, + overwrite=False, + template_renderer=dummy_template_renderer) + # toplevel file + toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py') + with open(toplevel, 'w') as f: + f.write('These are the words you are looking for.') + # sub directory file + sub = os.path.join(self.dirname, 'mypackage', 'templates', 'mytemplate.pt') + with open(sub, 'w') as f: + f.write('These are the words you are looking for.') + self._callFUT(source, + self.dirname, + vars, + 1, False, + overwrite=False, + template_renderer=dummy_template_renderer) + with open(toplevel, 'r') as f: + tcontent = f.read() + self.assertEqual('These are the words you are looking for.', tcontent) + with open(sub, 'r') as f: + tcontent = f.read() + self.assertEqual('These are the words you are looking for.', tcontent) + + def test_overwrite_true(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + self._callFUT(source, + self.dirname, + vars, + 1, False, + overwrite=True, + template_renderer=dummy_template_renderer) + # toplevel file + toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py') + with open(toplevel, 'w') as f: + f.write('These are not the words you are looking for.') + # sub directory file + sub = os.path.join(self.dirname, 'mypackage', 'templates', 'mytemplate.pt') + with open(sub, 'w') as f: + f.write('These are not the words you are looking for.') + self._callFUT(source, + self.dirname, + vars, + 1, False, + overwrite=True, + template_renderer=dummy_template_renderer) + with open(toplevel, 'r') as f: + tcontent = f.read() + self.assertNotEqual('These are not the words you are looking for.', tcontent) + with open(sub, 'r') as f: + tcontent = f.read() + self.assertNotEqual('These are not the words you are looking for.', tcontent) + + def test_detect_SkipTemplate(self): + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + def dummy_template_renderer(*args, **kwargs): + from pyramid.scaffolds.copydir import SkipTemplate + raise SkipTemplate + self._callFUT(source, + self.dirname, + vars, + 1, False, + template_renderer=dummy_template_renderer) + + def test_query_interactive(self): + from pyramid.scaffolds import copydir + vars = {'package':'mypackage'} + source = pkg_resources.resource_filename(*self.fixturetuple) + self._callFUT(source, + self.dirname, + vars, + 1, False, + overwrite=False, + template_renderer=dummy_template_renderer) + target = os.path.join(self.dirname, 'mypackage', '__init__.py') + with open(target, 'w') as f: + f.write('These are not the words you are looking for.') + # We need query_interactive to return False in order to force + # execution of a branch + original_code_object = copydir.query_interactive + copydir.query_interactive = lambda *args, **kwargs: False + self._callFUT(source, + self.dirname, + vars, + 1, False, + interactive=True, + overwrite=False, + template_renderer=dummy_template_renderer) + copydir.query_interactive = original_code_object + +class Test_raise_SkipTemplate(unittest.TestCase): + + def _callFUT(self, *arg, **kw): + from pyramid.scaffolds.copydir import skip_template + return skip_template(*arg, **kw) + + def test_raise_SkipTemplate(self): + from pyramid.scaffolds.copydir import SkipTemplate + self.assertRaises(SkipTemplate, + self._callFUT, True, "exc-message") + +class Test_makedirs(unittest.TestCase): + + def _callFUT(self, *arg, **kw): + from pyramid.scaffolds.copydir import makedirs + return makedirs(*arg, **kw) + + def test_makedirs_parent_dir(self): + import shutil + import tempfile + tmpdir = tempfile.mkdtemp() + target = os.path.join(tmpdir, 'nonexistent_subdir') + self._callFUT(target, 2, None) + shutil.rmtree(tmpdir) + + def test_makedirs_no_parent_dir(self): + import shutil + import tempfile + tmpdir = tempfile.mkdtemp() + target = os.path.join(tmpdir, 'nonexistent_subdir', 'non2') + self._callFUT(target, 2, None) + shutil.rmtree(tmpdir) + +class Test_support_functions(unittest.TestCase): + + def _call_html_quote(self, *arg, **kw): + from pyramid.scaffolds.copydir import html_quote + return html_quote(*arg, **kw) + + def _call_url_quote(self, *arg, **kw): + from pyramid.scaffolds.copydir import url_quote + return url_quote(*arg, **kw) + + def _call_test(self, *arg, **kw): + from pyramid.scaffolds.copydir import test + return test(*arg, **kw) + + def test_html_quote(self): + import string + s = None + self.assertEqual(self._call_html_quote(s), '') + s = string.ascii_letters + self.assertEqual(self._call_html_quote(s), s) + s = "Λεμεσός" + self.assertEqual(self._call_url_quote(s), + "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82") + + def test_url_quote(self): + import string + s = None + self.assertEqual(self._call_url_quote(s), '') + s = string.ascii_letters + self.assertEqual(self._call_url_quote(s), s) + s = "Λεμεσός" + self.assertEqual(self._call_url_quote(s), + "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82") + + def test_test(self): + conf = True + true_cond = "faked" + self.assertEqual(self._call_test( + conf, true_cond, false_cond=None), "faked") + conf = False + self.assertEqual(self._call_test( + conf, true_cond, false_cond="alsofaked"), "alsofaked") + + +class Test_should_skip_file(unittest.TestCase): + + def _callFUT(self, *arg, **kw): + from pyramid.scaffolds.copydir import should_skip_file + return should_skip_file(*arg, **kw) + + def test_should_skip_dot_hidden_file(self): + self.assertEqual( + self._callFUT('.a_filename'), + 'Skipping hidden file %(filename)s') + + def test_should_skip_backup_file(self): + for name in ('a_filename~', 'a_filename.bak'): + self.assertEqual( + self._callFUT(name), + 'Skipping backup file %(filename)s') + + def test_should_skip_bytecompiled_file(self): + for name in ('afilename.pyc', 'afilename.pyo'): + extension = os.path.splitext(name)[1] + self.assertEqual( + self._callFUT(name), + 'Skipping %s file ' % extension + '%(filename)s') + + def test_should_skip_jython_class_file(self): + self.assertEqual( + self._callFUT('afilename$py.class'), + 'Skipping $py.class file %(filename)s') + + def test_should_skip_version_control_directory(self): + for name in ('CVS', '_darcs'): + self.assertEqual( + self._callFUT(name), + 'Skipping version control directory %(filename)s') + + def test_valid_file_is_not_skipped(self): + self.assertEqual( + self._callFUT('a_filename'), None) + +class RawInputMockObject( object ): + count = 0 + def __init__( self, fake_input ): + self.input= fake_input + self.count = 0 + def __call__( self, prompt ): + # Don't cycle endlessly. + self.count += 1 + if self.count > 1: + return 'y' + else: + return self.input + +class Test_query_interactive(unittest.TestCase): + + def setUp(self): + import tempfile + from pyramid.compat import NativeIO + self.dirname = tempfile.mkdtemp() + self.out = NativeIO() + self.fixturetuple = ('tests.test_scaffolds', 'fixture_scaffold') + self.src_content = """\ +These are not the droids +that you are looking for.""" + self.dest_content = """\ +These are the droids for +whom you are looking; +now you have found them.""" + self.src_fn = os.path.join(self.dirname, 'mypackage', '__init__.py') + self.dest_fn = os.path.join(self.dirname, 'mypackage', '__init__.py') + # query_interactive is only normally executed when the destination + # is discovered to be already occupied by existing files, so ... + # create the required occupancy. + from pyramid.scaffolds.copydir import copy_dir + copy_dir(self.fixturetuple, + self.dirname, + {'package':'mypackage'}, + 0, False, + template_renderer=dummy_template_renderer) + + def tearDown(self): + import shutil + shutil.rmtree(self.dirname, ignore_errors=True) + self.out.close() + + def _callFUT(self, *arg, **kw): + from pyramid.scaffolds.copydir import query_interactive + return query_interactive(*arg, **kw) + + def test_query_interactive_0y(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("y") + self._callFUT(self.src_fn, self.dest_fn, + self.src_content, self.dest_content, + simulate=False, + out_=self.out) + self.assertTrue("Replace" in self.out.getvalue()) + + def test_query_interactive_1n(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("n") + self._callFUT(self.src_fn, self.dest_fn, + self.src_content, + '\n'.join(self.dest_content.split('\n')[:-1]), + simulate=False, + out_=self.out) + self.assertTrue("Replace" in self.out.getvalue()) + + def test_query_interactive_2b(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("b") + with open(os.path.join( + self.dirname, 'mypackage', '__init__.py.bak'), 'w') as fp: + fp.write("") + fp.close() + self._callFUT(self.src_fn, self.dest_fn, + self.dest_content, self.src_content, + simulate=False, + out_=self.out) + self.assertTrue("Backing up" in self.out.getvalue()) + + def test_query_interactive_3d(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("d") + self._callFUT(self.src_fn, self.dest_fn, + self.dest_content, self.src_content, + simulate=False, + out_=self.out) + output = self.out.getvalue() + # The useful text in self.out gets wiped out on the second + # call to raw_input, otherwise the test could be made + # more usefully precise... + # print("3d", output) + # self.assertTrue("@@" in output, output) + self.assertTrue("Replace" in output) + + def test_query_interactive_4dc(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("dc") + self._callFUT(self.src_fn, self.dest_fn, + self.dest_content, self.src_content, + simulate=False, + out_=self.out) + output = self.out.getvalue() + # The useful text in self.out gets wiped out on the second + # call to raw_input, otherwise, the test could be made + # more usefully precise... + # print("4dc", output) + # self.assertTrue("***" in output, output) + self.assertTrue("Replace" in output) + + def test_query_interactive_5allbad(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("all z") + self._callFUT(self.src_fn, self.dest_fn, + self.src_content, self.dest_content, + simulate=False, + out_=self.out) + output = self.out.getvalue() + # The useful text in self.out gets wiped out on the second + # call to raw_input, otherwise the test could be made + # more usefully precise... + # print("5allbad", output) + # self.assertTrue("Responses" in output, output) + self.assertTrue("Replace" in output) + + def test_query_interactive_6all(self): + from pyramid.scaffolds import copydir + copydir.input_ = RawInputMockObject("all b") + self._callFUT(self.src_fn, self.dest_fn, + self.src_content, self.dest_content, + simulate=False, + out_=self.out) + output = self.out.getvalue() + # The useful text in self.out gets wiped out on the second + # call to raw_input, otherwise the test could be made + # more usefully precise... + # print("6all", output) + # self.assertTrue("Responses" in output, output) + self.assertTrue("Replace" in output) + +def dummy_template_renderer(content, v, filename=None): + return content + |